{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# General API quickstart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on PyMC3 v3.6\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import theano.tensor as tt\n",
    "import pymc3 as pm\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sns.set_context('notebook')\n",
    "plt.style.use('seaborn-darkgrid')\n",
    "print('Running on PyMC3 v{}'.format(pm.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Model creation\n",
    "\n",
    "Models in PyMC3 are centered around the `Model` class. It has references to all random variables (RVs) and computes the model logp and its gradients. Usually, you would instantiate it as part of a `with` context:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model() as model:\n",
    "    # Model definition\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We discuss RVs further below but let's create a simple model to explore the `Model` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=1, observed=np.random.randn(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[mu, obs]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.basic_RVs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[mu]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.free_RVs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[obs]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.observed_RVs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(-141.37324441)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.logp({'mu': 0})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning**\n",
    "It's worth highlighting one of the counter-intuitive design choices with logp. \n",
    "The API makes the `logp` look like an attribute, when it actually puts together a function based on the current state of the model. \n",
    "\n",
    "The current design is super maintainable, does terrible if the state stays constant, and great if the state keeps changing, for reasons of design we assume that `Model` isn't static, in fact it's best in our experience and avoids bad results. \n",
    "\n",
    "If you need to use `logp` in an inner loop and it needs to be static, simply use something like `logp = model.logp` below. You can see the caching effect with the speed up below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.5 ms ± 356 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "12.3 µs ± 173 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit model.logp({mu: 0.1})\n",
    "logp = model.logp\n",
    "%timeit logp({mu: 0.1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Probability Distributions\n",
    "\n",
    "Every probabilistic program consists of observed and unobserved Random Variables (RVs). Observed RVs are defined via likelihood distributions, while unobserved RVs are defined via prior distributions. In PyMC3, probability distributions are available from the main module space:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Normal in module pymc3.distributions.continuous:\n",
      "\n",
      "class Normal(pymc3.distributions.distribution.Continuous)\n",
      " |  Normal(name, *args, **kwargs)\n",
      " |  \n",
      " |  Univariate normal log-likelihood.\n",
      " |  \n",
      " |  The pdf of this distribution is\n",
      " |  \n",
      " |  .. math::\n",
      " |  \n",
      " |     f(x \\mid \\mu, \\tau) =\n",
      " |         \\sqrt{\\frac{\\tau}{2\\pi}}\n",
      " |         \\exp\\left\\{ -\\frac{\\tau}{2} (x-\\mu)^2 \\right\\}\n",
      " |  \n",
      " |  Normal distribution can be parameterized either in terms of precision\n",
      " |  or standard deviation. The link between the two parametrizations is\n",
      " |  given by\n",
      " |  \n",
      " |  .. math::\n",
      " |  \n",
      " |     \\tau = \\dfrac{1}{\\sigma^2}\n",
      " |  \n",
      " |  .. plot::\n",
      " |  \n",
      " |      import matplotlib.pyplot as plt\n",
      " |      import numpy as np\n",
      " |      import scipy.stats as st\n",
      " |      plt.style.use('seaborn-darkgrid')\n",
      " |      x = np.linspace(-5, 5, 1000)\n",
      " |      mus = [0., 0., 0., -2.]\n",
      " |      sigmas = [0.4, 1., 2., 0.4]\n",
      " |      for mu, sigma in zip(mus, sigmas):\n",
      " |          pdf = st.norm.pdf(x, mu, sigma)\n",
      " |          plt.plot(x, pdf, label=r'$\\mu$ = {}, $\\sigma$ = {}'.format(mu, sigma))\n",
      " |      plt.xlabel('x', fontsize=12)\n",
      " |      plt.ylabel('f(x)', fontsize=12)\n",
      " |      plt.legend(loc=1)\n",
      " |      plt.show()\n",
      " |  \n",
      " |  ========  ==========================================\n",
      " |  Support   :math:`x \\in \\mathbb{R}`\n",
      " |  Mean      :math:`\\mu`\n",
      " |  Variance  :math:`\\dfrac{1}{\\tau}` or :math:`\\sigma^2`\n",
      " |  ========  ==========================================\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  mu : float\n",
      " |      Mean.\n",
      " |  sigma : float\n",
      " |      Standard deviation (sigma > 0) (only required if tau is not specified).\n",
      " |  tau : float\n",
      " |      Precision (tau > 0) (only required if sigma is not specified).\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  .. code-block:: python\n",
      " |  \n",
      " |      with pm.Model():\n",
      " |          x = pm.Normal('x', mu=0, sigma=10)\n",
      " |  \n",
      " |      with pm.Model():\n",
      " |          x = pm.Normal('x', mu=0, tau=1/23)\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Normal\n",
      " |      pymc3.distributions.distribution.Continuous\n",
      " |      pymc3.distributions.distribution.Distribution\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, mu=0, sigma=None, tau=None, sd=None, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  logcdf(self, value)\n",
      " |  \n",
      " |  logp(self, value)\n",
      " |      Calculate log-probability of Normal distribution at specified value.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      value : numeric\n",
      " |          Value(s) for which log-probability is calculated. If the log probabilities for multiple\n",
      " |          values are desired the values must be provided in a numpy array or theano tensor\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      TensorVariable\n",
      " |  \n",
      " |  random(self, point=None, size=None)\n",
      " |      Draw random values from Normal distribution.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      point : dict, optional\n",
      " |          Dict of variable values on which random values are to be\n",
      " |          conditioned (uses default point if not specified).\n",
      " |      size : int, optional\n",
      " |          Desired size of random sample (returns one sample if not\n",
      " |          specified).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      array\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from pymc3.distributions.distribution.Distribution:\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __latex__ = _repr_latex_(self, name=None, dist=None)\n",
      " |      Magic method name for IPython to use for LaTeX formatting.\n",
      " |  \n",
      " |  default(self)\n",
      " |  \n",
      " |  get_test_val(self, val, defaults)\n",
      " |  \n",
      " |  getattr_value(self, val)\n",
      " |  \n",
      " |  logp_nojac(self, *args, **kwargs)\n",
      " |      Return the logp, but do not include a jacobian term for transforms.\n",
      " |      \n",
      " |      If we use different parametrizations for the same distribution, we\n",
      " |      need to add the determinant of the jacobian of the transformation\n",
      " |      to make sure the densities still describe the same distribution.\n",
      " |      However, MAP estimates are not invariant with respect to the\n",
      " |      parametrization, we need to exclude the jacobian terms in this case.\n",
      " |      \n",
      " |      This function should be overwritten in base classes for transformed\n",
      " |      distributions.\n",
      " |  \n",
      " |  logp_sum(self, *args, **kwargs)\n",
      " |      Return the sum of the logp values for the given observations.\n",
      " |      \n",
      " |      Subclasses can use this to improve the speed of logp evaluations\n",
      " |      if only the sum of the logp values is needed.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from pymc3.distributions.distribution.Distribution:\n",
      " |  \n",
      " |  dist(*args, **kwargs) from builtins.type\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from pymc3.distributions.distribution.Distribution:\n",
      " |  \n",
      " |  __new__(cls, name, *args, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from pymc3.distributions.distribution.Distribution:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(pm.Normal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the PyMC3 module, the structure for probability distributions looks like this:\n",
    "\n",
    "[pymc3.distributions](../api/distributions.rst)\n",
    "- [continuous](../api/distributions/continuous.rst)\n",
    "- [discrete](../api/distributions/discrete.rst)\n",
    "- [timeseries](../api/distributions/timeseries.rst)\n",
    "- [mixture](../api/distributions/mixture.rst)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Discrete',\n",
       " 'Distribution',\n",
       " 'Iterable',\n",
       " 'Mixture',\n",
       " 'Normal',\n",
       " 'NormalMixture',\n",
       " '_DrawValuesContext',\n",
       " '_DrawValuesContextBlocker',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_conversion_map',\n",
       " 'all_discrete',\n",
       " 'bound',\n",
       " 'broadcast_distribution_samples',\n",
       " 'draw_values',\n",
       " 'generate_samples',\n",
       " 'get_tau_sigma',\n",
       " 'get_variable_name',\n",
       " 'logsumexp',\n",
       " 'np',\n",
       " 'random_choice',\n",
       " 'theano',\n",
       " 'to_tuple',\n",
       " 'tt']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(pm.distributions.mixture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unobserved Random Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every unobserved RV has the following calling signature: name (str), parameter keyword arguments. Thus, a normal prior can be defined in a model context like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model():\n",
    "    x = pm.Normal('x', mu=0, sigma=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with the model, we can evaluate its logp:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(-0.91893853)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.logp({'x': 0})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observed Random Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observed RVs are defined just like unobserved RVs but require data to be passed into the `observed` keyword argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model():\n",
    "    obs = pm.Normal('x', mu=0, sigma=1, observed=np.random.randn(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`observed` supports lists, `numpy.ndarray`, `theano` and `pandas` data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deterministic transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyMC3 allows you to freely do algebra with RVs in all kinds of ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model():\n",
    "    x = pm.Normal('x', mu=0, sigma=1)\n",
    "    y = pm.Gamma('y', alpha=1, beta=1)\n",
    "    plus_2 = x + 2\n",
    "    summed = x + y\n",
    "    squared = x**2\n",
    "    sined = pm.math.sin(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While these transformations work seamlessly, their results are not stored automatically. Thus, if you want to keep track of a transformed variable, you have to use `pm.Deterministic`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model():\n",
    "    x = pm.Normal('x', mu=0, sigma=1)\n",
    "    plus_2 = pm.Deterministic('x plus 2', x + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `plus_2` can be used in the identical way to above, we only tell PyMC3 to keep track of this RV for us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatic transforms of bounded RVs\n",
    "\n",
    "In order to sample models more efficiently, PyMC3 automatically transforms bounded RVs to be unbounded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model() as model:\n",
    "    x = pm.Uniform('x', lower=0, upper=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we look at the RVs of the model, we would expect to find `x` there, however:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[x_interval__]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.free_RVs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x_interval__` represents `x` transformed to accept parameter values between -inf and +inf. In the case of an upper and a lower bound, a `LogOdd`s transform is applied. Sampling in this transformed space makes it easier for the sampler. PyMC3 also keeps track of the non-transformed, bounded parameters. These are common determinstics (see above): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[x]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.deterministics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When displaying results, PyMC3 will usually hide transformed parameters. You can pass the `include_transformed=True` parameter to many functions to see the transformed parameters that are used for sampling.\n",
    "\n",
    "You can also turn transforms off:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[x]\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    x = pm.Uniform('x', lower=0, upper=1, transform=None)\n",
    "    \n",
    "print(model.free_RVs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or specify different transformation other than the default:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The default transformation of x1 is: log\n",
      "The user specified transformation of x2 is: log_exp_m1\n"
     ]
    }
   ],
   "source": [
    "import pymc3.distributions.transforms as tr\n",
    "\n",
    "with pm.Model() as model:\n",
    "    # use the default log transformation\n",
    "    x1 = pm.Gamma('x1', alpha=1, beta=1)\n",
    "    # sepcified a different transformation\n",
    "    x2 = pm.Gamma('x2', alpha=1, beta=1, transform=tr.log_exp_m1)\n",
    "\n",
    "print('The default transformation of x1 is: ' + x1.transformation.name)\n",
    "print('The user specified transformation of x2 is: ' + x2.transformation.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transformed distributions and changes of variables\n",
    "PyMC3 does not provide explicit functionality to transform one distribution to another. Instead, a dedicated distribution is usually created in consideration of optimising performance. However, users can still create transformed distribution by passing the inverse transformation to `transform` kwarg. Take the classical textbook example of LogNormal: $log(y) \\sim \\text{Normal}(\\mu, \\sigma)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Exp(tr.ElemwiseTransform):\n",
    "    name = \"exp\"\n",
    "\n",
    "    def backward(self, x):\n",
    "        return tt.log(x)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return tt.exp(x)\n",
    "\n",
    "    def jacobian_det(self, x):\n",
    "        return -tt.log(x)\n",
    "\n",
    "\n",
    "with pm.Model() as model:\n",
    "    x1 = pm.Normal('x1', 0., 1., transform=Exp())\n",
    "    x2 = pm.Lognormal('x2', 0., 1.)\n",
    "\n",
    "lognorm1 = model.named_vars['x1_exp__']\n",
    "lognorm2 = model.named_vars['x2']\n",
    "\n",
    "_, ax = plt.subplots(1, 1, figsize=(5, 3))\n",
    "x = np.linspace(0., 10., 100)\n",
    "ax.plot(\n",
    "    x,\n",
    "    np.exp(lognorm1.distribution.logp(x).eval()),\n",
    "    '--',\n",
    "    alpha=.5,\n",
    "    label='log(y) ~ Normal(0, 1)')\n",
    "ax.plot(\n",
    "    x,\n",
    "    np.exp(lognorm2.distribution.logp(x).eval()),\n",
    "    alpha=.5,\n",
    "    label='y ~ Lognormal(0, 1)')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice from above that the named variable `x1_exp__` in the `model` is Lognormal distributed.  \n",
    "Using similar approach, we can create ordered RVs following some distribution. For example, we can combine the `ordered` transformation and `logodds` transformation using `Chain` to create a 2D RV that satisfy $x_1, x_2 \\sim \\text{Uniform}(0, 1) \\space and \\space x_1< x_2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [x]\n",
      "The acceptance probability does not match the target. It is 0.8884785458718986, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "There were 2 divergences after tuning. Increase `target_accept` or reparameterize.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Order = tr.Ordered()\n",
    "Logodd = tr.LogOdds()\n",
    "chain_tran = tr.Chain([Logodd, Order])\n",
    "\n",
    "with pm.Model() as m0:\n",
    "    x = pm.Uniform(\n",
    "        'x', 0., 1., shape=2, \n",
    "        transform=chain_tran, \n",
    "        testval=[0.1, 0.9])\n",
    "    trace = pm.sample(5000, tune=1000, progressbar=False)\n",
    "\n",
    "_, ax = plt.subplots(1, 2, figsize=(10, 5))\n",
    "for ivar, varname in enumerate(trace.varnames):\n",
    "    ax[ivar].scatter(trace[varname][:, 0], trace[varname][:, 1], alpha=.01)\n",
    "    ax[ivar].set_xlabel(varname + '[0]')\n",
    "    ax[ivar].set_ylabel(varname + '[1]')\n",
    "    ax[ivar].set_title(varname)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists of RVs / higher-dimensional RVs\n",
    "\n",
    "Above we have seen how to create scalar RVs. In many models, you want multiple RVs. There is a tendency (mainly inherited from PyMC 2.x) to create list of RVs, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model():\n",
    "    x = [pm.Normal('x_{}'.format(i), mu=0, sigma=1) for i in range(10)] # bad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, even though this works it is quite slow and not recommended. Instead, use the `shape` kwarg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pm.Model() as model:\n",
    "    x = pm.Normal('x', mu=0, sigma=1, shape=10) # good"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x` is now a random vector of length 10. We can index into it or do linear algebra operations on it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "with model:\n",
    "    y = x[0] * x[1] # full indexing is supported\n",
    "    x.dot(x.T) # Linear algebra is supported"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization with test_values\n",
    "\n",
    "While PyMC3 tries to automatically initialize models it is sometimes helpful to define initial values for RVs. This can be done via the `testval` kwarg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with pm.Model():\n",
    "    x = pm.Normal('x', mu=0, sigma=1, shape=5)\n",
    "\n",
    "x.tag.test_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.31813596, -0.44557099,  0.04482665, -1.8167009 ,  0.94796326])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with pm.Model():\n",
    "    x = pm.Normal('x', mu=0, sigma=1, shape=5, testval=np.random.randn(5))\n",
    "\n",
    "x.tag.test_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This technique is quite useful to identify problems with model specification or initialization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Inference\n",
    "\n",
    "Once we have defined our model, we have to perform inference to approximate the posterior distribution. PyMC3 supports two broad classes of inference: sampling and variational inference.\n",
    "\n",
    "### 3.1 Sampling\n",
    "\n",
    "The main entry point to MCMC sampling algorithms is via the `pm.sample()` function. By default, this function tries to auto-assign the right sampler(s) and auto-initialize if you don't pass anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [mu]\n",
      "Sampling 4 chains: 100%|██████████| 6000/6000 [00:00<00:00, 7221.92draws/s]\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=1, observed=np.random.randn(100))\n",
    "    \n",
    "    trace = pm.sample(1000, tune=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, on a continuous model, PyMC3 assigns the NUTS sampler, which is very efficient even for complex models. PyMC3 also runs variational inference (i.e. ADVI) to find good starting parameters for the sampler. Here we draw 1000 samples from the posterior and allow the sampler to adjust its parameters in an additional 500 iterations. These 500 samples are discarded by default:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(trace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also run multiple chains in parallel using the `cores` kwarg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [mu]\n",
      "Sampling 4 chains: 100%|██████████| 4000/4000 [00:00<00:00, 7935.96draws/s]\n",
      "The acceptance probability does not match the target. It is 0.8978219346041421, but should be close to 0.8. Try to increase the number of tuning steps.\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=1, observed=np.random.randn(100))\n",
    "    \n",
    "    trace = pm.sample(cores=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, that we are now drawing 2000 samples, 500 samples for 4 chains each. The 500 tuning samples are discarded by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2000,)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace['mu'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace.nchains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500,)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trace.get_values('mu', chains=1).shape # get values of a single chain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyMC3, offers a variety of other samplers, found in `pm.step_methods`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BinaryGibbsMetropolis',\n",
       " 'BinaryMetropolis',\n",
       " 'CategoricalGibbsMetropolis',\n",
       " 'CauchyProposal',\n",
       " 'CompoundStep',\n",
       " 'DEMetropolis',\n",
       " 'ElemwiseCategorical',\n",
       " 'EllipticalSlice',\n",
       " 'HamiltonianMC',\n",
       " 'LaplaceProposal',\n",
       " 'Metropolis',\n",
       " 'MultivariateNormalProposal',\n",
       " 'NUTS',\n",
       " 'NormalProposal',\n",
       " 'PoissonProposal',\n",
       " 'SMC',\n",
       " 'Slice']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x[0].isupper(), dir(pm.step_methods)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commonly used step-methods besides NUTS are `Metropolis` and `Slice`. **For almost all continuous models, `NUTS` should be preferred.** There are hard-to-sample models for which `NUTS` will be very slow causing many users to use `Metropolis` instead. This practice, however, is rarely successful. NUTS is fast on simple models but can be slow if the model is very complex or it is badly initialized. In the case of a complex model that is hard for NUTS, Metropolis, while faster, will have a very low effective sample size or not converge properly at all. A better approach is to instead try to improve initialization of NUTS, or reparameterize the model.\n",
    "\n",
    "For completeness, other sampling methods can be passed to sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "Metropolis: [mu]\n",
      "Sampling 4 chains: 100%|██████████| 6000/6000 [00:00<00:00, 14925.91draws/s]\n",
      "The number of effective samples is smaller than 25% for some parameters.\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=1, observed=np.random.randn(100))\n",
    "    \n",
    "    step = pm.Metropolis()\n",
    "    trace = pm.sample(1000, step=step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also assign variables to different step methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "CompoundStep\n",
      ">Metropolis: [mu]\n",
      ">Slice: [sd]\n",
      "Sampling 4 chains: 100%|██████████| 42000/42000 [00:04<00:00, 8735.76draws/s]\n",
      "The number of effective samples is smaller than 25% for some parameters.\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    sd = pm.HalfNormal('sd', sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=sd, observed=np.random.randn(100))\n",
    "    \n",
    "    step1 = pm.Metropolis(vars=[mu])\n",
    "    step2 = pm.Slice(vars=[sd])\n",
    "    trace = pm.sample(10000, step=[step1, step2], cores=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Analyze sampling results\n",
    "\n",
    "The most common used plot to analyze sampling results is the so-called trace-plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/canyon/miniconda3/envs/pymc/lib/python3.7/site-packages/arviz/data/io_pymc3.py:56: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
      "  chain_likelihoods.append(np.stack(log_like))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pm.traceplot(trace);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another common metric to look at is R-hat, also known as the Gelman-Rubin statistic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'mu': 1.0006472993307545, 'sd': 0.9999963951762092}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pm.rhat(trace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are also part of the `forestplot`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/canyon/miniconda3/envs/pymc/lib/python3.7/site-packages/arviz/data/io_pymc3.py:56: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
      "  chain_likelihoods.append(np.stack(log_like))\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbgAAAGpCAYAAAD/QCONAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAGh1JREFUeJzt3Xt0nHd54PGvHWMpDMJppSBjLusogR8X0+DlbgoBErpLewzl0jUXr0lo67BdSmlZCoXmbJfSUna59ZClsU0hOOkBA8u13JqSspzFKS3EiUtJntKobkhUG8sktpgTSzjW/vG+DooiSxp5PCM9+X7OyTkezTvvPFI0+ur3m7Fn2eTkJJIkZbO82wNIknQ6GDhJUkoGTpKUkoGTJKVk4CRJKRk4SVJKK7o9gDSTUsoW4M1AH/B/gV+LiPFpx3wKGIiI58xw+2XAO4EXA5PAZyLi9+rr3g68CrgJeOmJ85ZSXgE8IyJeP8tcTwP+CPh3VL8g7gMui4jdp/j5/j5wXkRcXEr5GvAm4MHAhyLivBmOvxL454h4Rwv3Ma/b1J/jXRGxt4VPYUFKKZPAIyLittN9X7r/cQWnRaeUsg54L/AfqUJyBvC70475JeDJs5xmE/Ac4Ofq/55TSnlZKWWQKnqPBm4DXlif78FUUblslrmeCHwJuDwiHhUR5wJ/Cny5lPL41j/TmUXEhRFxfbvOtwCXUH3NpCXNFZwWo+cB10bEDwBKKe8HtgN/WF9+IPC/gD8ALj7JOX4FuHLK6uyq+mMjwHcj4u5Syh7gUfXx/wN4X0QcnmWutwHbIuKzJz4QEZ8vpbwE+GEpZS2wG9gF/PuIuKCU8kzg/cDPAKPAKyNiuJRyJnAl8HSqVeDNJ85ZStkHbJ5y+d1UIT4OvGb6arGU8jjgz4CHAuPAJRHx7Vk+D0opfwAMAA8Dzq9ne1H93xbghaWUhwDvo4r+q4Be4LPA79Rfv68D3wReAlwFvCIinjDlPm4A3gLsAT4KrAV6gA9ExHtnm09qB1dwWowmqVZtJ/wYmLpN99+pfqDum+UcjwZumXL5FuAxVJFYVn/sDODuUsoTqFYsh0opXyyl7Cil9M5wzguAL07/YER8LSIO1hcHgBvquPUBXwDeWm8z/inwifq4S4DVwLlUgfiFk3wea4FvR8SjgfcA/3vqlaWU5VTR2Vkf81rgc6WU+fzy+ivAG+oZfkgVzyuAvwN+t47QZuA/AU+tjzsX+C9TzvEk4PHAu4GHl1LOqec6B3g48NfA7wP/EhGPAS4E3llKecQ85pNOiYHTYvQ14PmllHX1D+r/SrV6oI7Rf6D6gTqbBwJHp1y+C2hQrZTW1QG7ALieKjxvAN5F9cP8FuCVM5zzZ4EDc9zvA4DP1H9+FnBbRFwDEBEfA84rpTwSeDbw6Yg4FhGHgL88yfmO8tMofgJ44rT4PgZ4CPDh+j6+CRwENswxJ8A3IuJfI2KSapX1yBmO2Qh8OCIOR8Qx4ENUQT7hSxFxPCImqGL+wvrjLwY+W9/m9cBv1vMNA/uBc+Yxn3RKDJwWnYj4HtUPxI8D3wK+B9xZv3Dkg8BvRsRP5jhNkzqKtQcCP46IO4HLqX6gH6baottDFYUfR0QTuIGZn98brY+fzd0RcaT+81nAuaWUm0/8R7WFeDZVLKduh95xkvMdiojj9Z9PnPdnplx/Vv253TTlPh4C9M8xJ9Pu/27uvWqeev7/NuXc7wbOnHL9j6b8+VP8NHC/TLVVC/AU4KullO/X53go/uxRB/gcnBaliPgo1fM2lFKeDfwD8Aiq54s+WUoBWAk8qJSyNyKmvyjiZqptzWvqy4+iCiX1NtwVpZSzgGupVnJ9U267jJl/2P8N8FKqV3Xeo5RyST3f6LTjR4CbIuI+sSyl3AGsmvKhs2e4P7hvzODeURkBjtTbf6fDCPD5iLh8Hsd+FfhIKeVRVFvE19Yfv5rqubwrImKylHL76RlVujd/i9KiU0o5r5RyQynlrFLKA4C3Ur1g5NaIeHBErI6I1VRbZbtniBtU23lbSymNUsqDgK3Ax6Yd8w7gXRExRrX1+JD62KdRBWu6dwCbSymvnjLri4E/4aerq6m+BTy0ftk9pZShUspV9Ur0OqoXcpxRShkAfvEkX44H1vcB8DLg76f9dYl/BW4rpbysvo+BUsrHSimNk5xvPn7CT2P6OeA/1y/soZRy6dTPf6p6rq8C/xP4XETcXV/1EOA7ddxeTbVV/KBTmE+aFwOnRSci/pnqB+uNwPeBPfWKblallHeWUl5bn+NTwFeothuvB/5PRHxhyrHrgUdFxK76+LuBP67v87nAzhnm+kfg+VSRGy6l3AS8BrgwIv5phuPvoorSB+pjPwN8sn7OawfVFuEw8Gl++rzddDcDz6i39n6b6vnIqfcxCbwceF19zDeAr9VbrQv1GeBdpZT3Ur2A5QvA9fX5X0gVsZP5FNX25CemfOwy4DOllL1UYdsG7CilnHsKM0pzWub7wUmSMnIFJ0lKycBJklIycJKklAycJCmljv09uIMHx3w1iyTplJx9dt+yuY+quIKTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTpIRGmxPsHTnCaHOi26N0zYpuDyBJaq8v33SA91x7Cw8760xuv/Mu3vi8c3nBYwe7PVbHLZucnOzIHR08ONaZO5KkReLSXTe2/Zwjh4+yf2x81mN6Vixn5+b1DPU3GD7UZMvVexg/dnzOc6/u62HNqt52jcq2Tee37VwnnH1237L5HusWpSQlM9jXw1B/A4Ch/gaDfT1dnqg73KKUpNPkdKxgtu/ex47rbp31mANj4wwfat6zgjswx4rvhI3rBtm6YW0bplwc3KKUpGQyPwfXyhalgZOkhEabE4wcPsqaVb0MNFZ2e5y2aSVwblFKUkIDjZWpwrYQvshEkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZOkhEabE+wdOcJoc6Lbo3SNb5cjSclkfsPTVviGp5LUAZfuurFt5xo5fJT9Y+Mnvb5nxXJ2bl7PUH+D4UNNtly9h/Fjx+c87+q+Htas6m3bnCds23R+287VyhueukUpSckM9vUw1N8AYKi/wWBfT5cn6g63KCWpA9q5itm+ex87rrv1pNcfGBtn+FDznhXcgVlWe1NtXDfI1g1r2zRl97lFKUnJZH4OrpUtSgMnSQmNNicYOXyUNat6GWis7PY4bdNK4NyilKSEBhorU4VtIXyRiSQpJQMnSUrJwEmSUmpr4Eop55VS9rXznJIkLYQrOElSSi29irKUsgb4C2AZcCawDbgZuAI4CHyn3QNKkrQQra7gNgE3R8RzgAuABwLvBt4cERcC+9s7niRJC9Nq4L4MXFRKuRLYSLWCewLw/+rrr23faJIkLVxLgYuIm4HHAVcDFwFfp9quPPHPVJ/RzuEkSVqolgJXSnkl8JSI+GvgN4BHAv8EPKM+5KL2jidJ0sK0+k91fQ+4opQyTrVyexfwXeDyUsqtwJ42zydJ0oL4jy1LkpYM3/BUknS/Z+AkSSkZOElKaLQ5wd6RI4w2J7o9Stf4fnCSlEzmd/RuhS8ykaTT6NJdN7b1fCOHj7J/bHzWY3pWLGfn5vUM9TcYPtRky9V7GD92fNbbAKzu62HNqt52jQrAtk3nt/V8vshEku7HBvt6GOpvADDU32Cwr6fLE3WHW5SSdBq1ewWzffc+dlx366zHHBgbZ/hQ854V3IE5VnwnbFw3yNYNa9sw5eLgFqUkJZP5ObhWtigNnCQlNNqcYOTwUdas6mWgsbLb47RNK4Fzi1KSEhporEwVtoXwRSaSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnASZJSMnCSpJQMnCQlNNqcYO/IEUabE90epWt8uxxJSibzG562wjc8laQOuXTXjad8jpHDR9k/Nj7rMT0rlrNz83qG+hsMH2qy5eo9jB87Pue5V/f1sGZV7ynPOJNtm85vy3laecNTtyglKZnBvh6G+hsADPU3GOzr6fJE3eEWpSR1SDtWMdt372PHdbfOesyBsXGGDzXvWcEdmGPFd8LGdYNs3bD2lGdcLNyilKRkMj8H18oWpYGTpIRGmxOMHD7KmlW9DDRWdnuctmklcG5RSlJCA42VqcK2EL7IRJKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySlZOAkSSkZOElSSgZOkpSSgZMkpWTgJEkpGThJUkoGrkNGmxPsHTnCaHOi26NI0v3Cim4PcH/w5ZsO8J5rb+FhZ53J7XfexRufdy4veOxgt8eSpNSWTU5OduSODh4c68gdXbrrxtN6/pHDR9k/Nt7SbXpWLGfn5vUM9TcYPtRky9V7GD92vOX7Xt3Xw5pVvS3f7lRt23R+x+9TkmZy9tl9y+Z7rFuUHTDY18NQfwOAof4Gg309XZ5IkvJLt0V5ulcb23fvY8d1t7Z0mwNj4wwfat6zgjvQ4grwhI3rBtm6Ye2CbitJ9zfptigXI5+Dk6T2aGWL0sB1yGhzgpHDR1mzqpeBxspujyNJS1IrgUu3RblYDTRWGjZJ6iBfZCJJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnAddhoc4K9I0cYbU50exRJSs23y+kg3/hUkjpnyb3h6aW7bmzHaU7ZyOGj7B8bb+k2PSuWs3Pzeob6GwwfarLl6j2MHzu+oPtf3dfDmlW9C7rtfG3bdP5pPb8ktaqVNzx1i7KDBvt6GOpvADDU32Cwr6fLE0lSXktui3KxrCq2797Hjutubek2B8bGGT7UvGcFd6DFFeBUG9cNsnXD2gXfXpKyW3JblEuZz8FJ0qlpZYvSwHXYaHOCkcNHWbOql4HGym6PI0lLSiuBW3JblEvdQGOlYZOkDvBFJpKklAycJCklAydJSsnASZJSMnCSpJTmfBVlKeU5wNuA24CnAH8L7AVeDAwALwB+ADwgIo6VUi4GLoqIzadpZkmS5jTfFdxTgTcCTwZeBdwZEc8FvgO87DTNJknSgs3378HdFBE/AiilHAJ21x+/DVh1OgaTJOlUzHcFd2yWy9P/Vrl/i1mS1HXtepHJEeAR9Z+f26ZzSpK0YO0K3J8Af1VK+RKwr03nlCRpwfzHliVJS4ZveCpJut8zcB002pxg78gRRpsT3R5FktLz7XI6xDc7laTOSvEc3KW7bjxdp76PkcNH2T823vLtelYsZ+fm9Qz1Nxg+1GTL1XsYP3a85fOs7uthzarelm/Xqm2bzj/t9yFJrfI5uEVosK+Hof4GAEP9DQb7ero8kSTllmKLspOrje2797Hjultbvt2BsXGGDzXvWcEdWMAqEGDjukG2bli7oNtK0v1Jii3KpcDn4CTp1LWyRWngOmi0OcHI4aOsWdXLQMN/0UySWtVK4FJsUS4VA42Vhk2SOsQXmUiSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwHTLanGDvyBFGmxPdHkWS7hd8u5wO8M1OJanzltwbnl6668Z2nGbBRg4fZf/YeEu36VmxnJ2b1zPU32D4UJMtV+9h/NjxBc+wuq+HNat6F3z7+dq26fzTfh+S1IpW3vDULcoOGOzrYai/AcBQf4PBvp4uTyRJ+S25Lcpuryq2797Hjutubek2B8bGGT7UvGcFd6DFFeB0G9cNsnXD2lM6hyRlt+S2KJcin4OTpPZoZYvSwHXIaHOCkcNHWbOql4HGym6PI0lLUiuBW3JblEvVQGOlYZOkDvJFJpKklAycJCklAydJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKycBJklIycJKklAycJCklAydJSsnASZJSMnCSpJQMnCQpJQMnSUrJwEmSUjJwkqSUDJwkKSUDJ0lKadnk5GS3Z5Akqe1cwUmSUjJwkqSUDJwkKSUDJ0lKaUW3B5iPUsrTgPcBx4AmsCUiDp7k2EcA3wVeFBFf79iQs5jP/KWUJwCX1xd7gN+IiOs7Oui957kM+CVgGfDFiHj7tOt/DdhK9TndALwuIo53fNCTmMf8rwNeDdwN3AJcEhETHR90BnPNPuW43wJ+OyLWdnC8Oc3ja/9k4M+A48APgZdHRLPjg85gHrO/AdgETAB3AhdHxB0dH/QkSimrgb8AeiLi52e4frE/bueav6XH7VJZwV0JvCEing1cA/zRTAeVUpYB24CbOzfavFzJ3PN/GHh7RFwA/DHwns6Nd291kF8CPBt4FrCxlLJhyvUPBy4DfgF4JvAw4OVdGHVG85h/HfB64Ocj4ulAL/CKbsw63VyzTznu0VQ/iBeVeXztlwO7gNdHxNOAvwfu84OsG+b5ff964Fn14/T7wOu6MessPgb81UxXLPbHbW22+Vt+3C76wJVS1gJnRsTf1R/6BPCLJzn8tVQPmJs6MNq8tDD/RcC19Z9/CAyc/ulO6gXA5yJiov7t6HPce+aLgL+JiDsjYhL4JCf/f9INc83/PeBJETFeXz5Id7/eU801+4lIXAH8Vhfmm8tc868HxiLiOoCIeHtEfLULc85krtmbwCTQV18+i+p7ZzF5EfCtk1y32B+3MPv8LT9uF33ggDXA/imX9wMPnX5QKWUIeBXwjg7NNV/zmj8iDkfEZL0KfTPViq5bZpp5TQvXd9us80XE8YgYAyilnEO1EvpERyc8ufl8bd8EfCUiFs0vclPMNf95wEgp5YOllN2llD8vpTy4oxOe3FzfN3cAfwj8SyllmOpz+VBHJ5xDRByZ5erF/riddf6FPG4X1XNwpZRLuO9vpT+adnkZ1W9RU2+3HNhOtZ/8k1LK6RtyFgudf8rtHwB8lGpv//1tH3DhTjrzPK/vthnnK6U8luq39F+PiB90fKr5udfspZTHU600LuzaRK2Z6Wu/HvhVqh+w24G3AG/t8FzzMf1r/0jgbUCJiAOllA9Qzb7Yfqmer8X+uJ1RK4/bRRW4iPgI8JGpH6tfNPLNKR9aA9w+7aYFOAe4oo7bucBTSymvjYhvnL6J7+0U5qeUcgbwaeAfgd+rtxC65Qfcd8V227Trnz/L9d021/yUUh5H9SC5OCKm/v/ptrlmfynws8A36+/1h5ZSromIqf8/ummu+UeAmyLi3wBKKZ+nemphMZhr9qcDN0TEgfryXwK/06HZ2mGxP27n1OrjdtFvUdaFvqOU8sz6Q5uBz0875qaIODcinl4/+fhFqlchdixuJzOf+WuXVYfHW7ocN6i+fr9cSuktpfRSPfH+hSnXXwNcUErpr1fPr2Dmz6lbZp2/lLIS+DjVq/cWU9xgjtnr56x+bsr3+r8torjB3N87fws8vJRyIiTPpHrV82Iw1+w3A08spZxZX346i+j5/nlY7I/bWS3kcbuoVnCzuBi4vJQySbXl92qAUsrFwBkR8efdG21eLmbu+d8E/EMp5etTbndhRNzd2VEhIq4vpVwFfINqC+OqiPh2KeXjwBsj4vZSytuAr1C93Hg31epzUZhrfmAD8EjgPVO2s6+JiBlfndtJ8/nad3fC2c3ze+c1wOdLKXdRvVDgV7s48j3mMfveUsoHga/Xs98B/HoXR76Xegt1J9WLX86pf5Z8EXgSS+BxO9f8LOBx6z+2LElKadFvUUqStBAGTpKUkoGTJKVk4CRJKRk4SVJKBk6SlJKBkySl9P8BFpQPhc4wNVUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x417.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pm.forestplot(trace);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, for a plot of the posterior that is inspired by the book [Doing Bayesian Data Analysis](http://www.indiana.edu/~kruschke/DoingBayesianDataAnalysis/), you can use the:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 993.6x331.2 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pm.plot_posterior(trace);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For high-dimensional models it becomes cumbersome to look at all parameter's traces. When using `NUTS` we can look at the energy plot to assess problems of convergence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [x]\n",
      "Sampling 4 chains: 100%|██████████| 4000/4000 [00:01<00:00, 2280.44draws/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    x = pm.Normal('x', mu=0, sigma=1, shape=100)    \n",
    "    trace = pm.sample(cores=4)\n",
    "    \n",
    "pm.energyplot(trace);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information on sampler stats and the energy plot, see [here](sampler-stats.ipynb). For more information on identifying sampling problems and what to do about them, see [here](Diagnosing_biased_Inference_with_Divergences.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Variational inference\n",
    "\n",
    "PyMC3 supports various Variational Inference techniques. While these methods are much faster, they are often also less accurate and can lead to biased inference. The main entry point is `pymc3.fit()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Average Loss = 138.84: 100%|██████████| 10000/10000 [00:01<00:00, 6462.56it/s]\n",
      "Finished [100%]: Average Loss = 138.83\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    sd = pm.HalfNormal('sd', sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=sd, observed=np.random.randn(100))\n",
    "    \n",
    "    approx = pm.fit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The returned `Approximation` object has various capabilities, like drawing samples from the approximated posterior, which we can analyse like a regular sampling run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MultiTrace: 1 chains, 500 iterations, 3 variables>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "approx.sample(500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `variational` submodule offers a lot of flexibility in which VI to use and follows an object oriented design. For example, full-rank ADVI estimates a full covariance matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/10000 [00:00<?, ?it/s]/home/canyon/miniconda3/envs/pymc/lib/python3.7/site-packages/theano/tensor/subtensor.py:2339: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  out[0][inputs[2:]] = inputs[1]\n",
      "/home/canyon/miniconda3/envs/pymc/lib/python3.7/site-packages/theano/tensor/basic.py:6611: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result[diagonal_slice] = x\n",
      "/home/canyon/miniconda3/envs/pymc/lib/python3.7/site-packages/theano/tensor/subtensor.py:2197: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  rval = inputs[0].__getitem__(inputs[1:])\n",
      "Average Loss = 0.0068883: 100%|██████████| 10000/10000 [00:03<00:00, 2795.26it/s]\n",
      "Finished [100%]: Average Loss = 0.0065707\n"
     ]
    }
   ],
   "source": [
    "mu = pm.floatX([0., 0.])\n",
    "cov = pm.floatX([[1, .5], [.5, 1.]])\n",
    "with pm.Model() as model:\n",
    "    pm.MvNormal('x', mu=mu, cov=cov, shape=2)\n",
    "    approx = pm.fit(method='fullrank_advi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An equivalent expression using the object-oriented interface is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Average Loss = 0.01127: 100%|██████████| 10000/10000 [00:03<00:00, 2541.45it/s]\n",
      "Finished [100%]: Average Loss = 0.011343\n"
     ]
    }
   ],
   "source": [
    "with pm.Model() as model:\n",
    "    pm.MvNormal('x', mu=mu, cov=cov, shape=2)\n",
    "    approx = pm.FullRankADVI().fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/canyon/miniconda3/envs/pymc/lib/python3.7/site-packages/theano/tensor/subtensor.py:2339: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  out[0][inputs[2:]] = inputs[1]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD1CAYAAACbQ6S4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnWdAFFcXhp+l9ypVqm0FpSjYe+891thioqlfEtOLJrHEVBMTU4xJNImxV8QGKvaKooICK70ovXd22fl+oCACii1Kcp9fytyduXMY3j1z7rnnyCRJQiAQCASNA43HPQGBQCAQNBwh2gKBQNCIEKItEAgEjQgh2gKBQNCIEKItEAgEjQgh2gKBQNCI0HqUJ8/IKHji8wnNzQ3IySl+3NN44hB2qY2wSd0Iu9TmQW1iZWUsq+/Yf97T1tLSfNxTeCIRdqmNsEndCLvU5lHa5D8v2gKBQNCYEKItEAgEjQgh2gKBQNCIEKItEAgEjQgh2gKBQNCIEKItEAgEjYiHItpyufxbuVx++GGcSyAQCAT188CiLZfLewI+D2EuAoFAILgLDyTacrncEPgSePPhTEcgEAgEd+JBPe2vgW+AjIcwF4FAIBDchfuuPSKXywcAlgqFYpNcLnepa4y5uUGj2OJqZWX8uKfwRCLsUhthk7oRdqnNo7KJ7H57RMrl8l8BX6AM0AWaAzsUCsX0m2MaQ8EoKytjMjIKHvc0njiEXWojbFI3wi61eVCb3Klg1H172gqFYvbNf9/wtP+4VbAFAoFA8PARedoCgUDQiHgo9bQVCkU80PthnEsgEAgE9SM8bYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoQQbYFAIGhECNEWCASCRoTW456AQCB4OKhUKpKSk4iNjychMYH8ggKKioooLCxER0cHM1MzTE1NsbG2xqNNGxwdHJHJZI972oJ7RIi2QNBIycvP51LoJS6EXuLipUtExUSjUqmqjuvr6WNkZIShoQHl5eXk5uVRXFxcddzc3BwvD0+6de5C965dMTczfxy3IbhHhGgLBI0EpVJJeGQEZ4LPcvrsWSIUkUiShI62Dm3c3Zk8fiLNXF1p5uqKi5Mzurq6tc5RXl7OtZTrhIaFcSkslPMXQjh89AgaGhp4tvWgV48e9OnZG1sbm8dwh4KGIJMk6ZGdPCOj4NGd/CFhZWVMRkbB457GE4ewS23+SZsUFhaSkJRIfEICiqirXAkP52p0FEqlEg0NDdq4udOpQ0d827fHvbUbOjo693UdSZKIio7myPFjHDl+lOiYGAA82rZlYN/+DBowEBNj4zueQzwrtXlQm1hZGdcbtxKiLR64OhF2qc3DsolarSY7J5u09HTS0tNJT08nLSOdtLQ00tLTSUlNJTsnu2q8np4ebnI57q3daOPeBt/2PncV0vslKTmZoCOH2B90kOiYGHR1denfpy9jRoyijbt7nTFw8azURoj2I0Q8cHUj7FKbhtqkuLiY1LQ0UlJTSE1PIy0tjdSb4pyeTkZmRo3YM4Cujg42NjbYWNtga2ODk6Mjzo5OODs509TeHi2tfz6SeTUqiu3+fgTsD6S4pISunTvz4TvvY2lhUWOceFZqI0T7ESIeuLoRdqnN7TbJy8sjQhFJVEw0iUlJJCQmkpiUSG5eXo3PaWlpYWNtjbWVFdZW1lhZWWFrY4uttTXWVtbYWFtjYmLyxGZyFBUXs8N/Jyt//xUDQ0Pmv/s+XTt3qTounpXaPLGiLZfLPwX6U5nvfVyhUMy99bgQ7caLsEtNJEmiuCSX/UHHCLlwgSsR4Vy7fr3quIW5Bc5Ojjg6OOJg3xQ7W1vsbO2wsbHB0sICDY3GvyUiNi6O+Ys+ISY2lplTp/PCc7MB8azUxaMU7ft+55LL5cOA7sDNr9wzcrm8l0KhOHK/5xQIniRUKhWXwkI5dOQIx0+dIDUtDYAmlpZ4tGnLqOEjcW/dmlYtWz2yGPOTRDNXV1b9vJKvv/uWP/7+CzNTUyaNn/C4p/Wf40ECZQHAEYVCoQaQy+VZQJOHMiuB4DEhSRKXw6+wZ98+Dh87Qk5uLrq6unTu0JGX5jyLvGUbnBz/u5tSdHV1ee/NtykoLOS7n37A2tqaiU+NeNzT+k9x36KtUChUQCGAXC7vBMipFHKBoNGRk5vDnn372LlnNwmJCejp6dG9S1f69upNl06d0dfXf2LCAGq1muKSUkpLSzE3M0VTU/Mfvb6mpiaffDif/73xOh8vXohDUytatWjzj87hv8wDL0TK5fIewB/AeIVCEXLrMZWqQtLS+mcfKIHgXrgYGsaff69jX+ABypVK2nt7MWHcGIYMGoCRoeFjmVNZeTnXUlK5dj2VpGspJCZfIz7pGglJyaSkpVNQWMTNv1tDA33atG6FZxs3Bvbpga+35z82z7y8fCbPfJbEpCR+/HYpvXp0+8eu/R/gkS1E9gJWAGMUCkXk7cfFQmTj5d9sF7Vazakzp1m7cQMhFy9gZGjEkEGDGDtyFK4urvV+7kFtoqqoICMzk5S0dFLT0snMziY7N4fsnFyyc3LJyskhMzub/IKa19DW1qKpnR2O9vbYWFlhbGyEsaERuro6xCcmEX71KlExsShVKqaNf4rnZ0z7x1IEs7KymPveW1yNiqZXj568/PwLODk4/iPXfpJ5IrNH5HK5BXASGKxQKOLrGiNEu/Hyb7RLWVkZAQf2s27TBuITErCxtmbiU+MZPXwkBgYGd/18Q20iSRIpaWkoomOIjosjJj6BuIREkq5do0KtrjFWT1cXC3NzLMzNaGJhgaW5OZYW5thZ22Bna42djQ1WlpZ3DYGUlJay7Jdf2bFnL23krVj0/rs0tbO761wfBkZGWiz/eRVr1v1NWXk5g/oPYNjgoXh7ev7joZsnhSdVtN8G3gRu9bDXKBSK32/+R4h24+XfZJe8vDy2+m1n8/Zt5OTk0LJ5C56eNJn+ffrek0dan00ysrK4HBFJWEQkVyIjiYqNo+hGYSaZTIaDvR3NXVxwcXTE3tYGW2tr7GysaWJpiYG+/kO7T4CDx47z2bLvqaioYPqE8UweOxo9Pb2Heo3buWmXrKwsVq/5i737AygqKsLExIQuHTsxsF9/OnXo+Fg2CD0unkjRbghCtBsv/wa7xCcksGnbFnbv20tZWRndOndhysRJtPdud1/ZHzdtoqqoICw8guNnznD89Fnik5KAyjCGvEUL5C2a08LVlVbNm9HCxeWRi+btpKSl8e2KlRw5eQorS0vmzJjG0P790HpEXu/tz0ppaSknTp/i5OlTHDt5gvz8fMxMTenftx9TJ035TxSjEqL9CPk3iNOjoLHaRZIkzp4/x4bNmzh15jQ62joMGjCgqgLeg5BbkMmf63ew92AQObm5aGlp0d6jLV06+OLh7o68eXN0dLQf0p08OBcvX2H5b79zOSISfT09WjZvRusWLWjZzBUnBwdcHB0wMzV94Ovc6VlRKpWcDj7Lvv2BHDt+HE1NTb5YvISOvr4PfN0nGSHaj5DGKk6PmsZmF6VSSeDBA6zbtIGY2FgszC0YN3o0Y0aOxsL8/utES5LEsdNn+HPjJi5HRKKpqUmPzp0Y2LsXnXx8MDK8eyz8cSJJEifOnOX0+RAUMTFExcRSUlpaddzUxAR3eSu83N3xatuGNq3l6N5jxcCGPispqam89cG7JCcn8/VnX9DB598r3EK0HyGNTZz+KRqLXUrLyvDb5c/f69eSkZlJ82bNmDx+IgP79b/vcqVQKXZnQi7w65q/uRwRiYOdHdMnjaVH525YmJk16BwFhUXEJiWTeC2FpJQUrqdlkJdfQF5BATl5+ZSWlVGuVKFUKqlQq9HU0ECmIUNTQxNjQ0NMjA0xMzHGuWlTPFq3xKN1KxztbB9oY09FRQUpaekkJCeTmJxMbEICYeGRxCUmAmBoYEDvbl0Z2Kc3vt5eDQqp3MuzkpObwytvvE5ycjK//riCVi1b3ve9PMkI0X6ENBZx+qd50u1SVlbGjl3+rFn3N5lZWbTz8mLm1Ol09O3wwLsVY+Lj+frHnwkJDcPGyopZUyYzfGB/7OzM72iTjKxsTl24RGiEgrDIKOKTr1Ud09TUxNbKEnNTU0yNjTAzMUFfTxcdbW10tLXR0NBAkiTUkhqVqoLComLyCgrIzssnJiGRouISAKwszBnatyejBvSlqe3Diw3n5Rdw6coVDp84yeETJykqLsbSwpyxw4YydviwO35R3euzkpObw9hJExk0YADvvfn2w5j+E4cQ7UfIky5Oj4sn1S6SJBF05DA/rPiZlNQU2nl589zMWfi0a/fA584vKGD1ug1s3OGHoaEhc6ZPZdTgwVVx6tttIkkS0QmJHDkdzPHgECKiYwEwMTbCQ94SD3krWjVzwampHXbWVve9EKhWq4lLukaY4irHzp7n5PkLqNUSHTzb0rdrJ7r4eGNnbfXA93+TsvJyTgWfY8fefZwKPoe2thaD+vRhxqQJODVtWmv8/Twr8xZ8zPkLIezauuNfmRYoRPsR8qSK0+PmSbRLVEw033y/jAuXLtG8WTNefekVOvl2eODzqtVqdu4L5MdVqykoLGTkoIG8NGtmrUW6mza5npZOwJETBB47QWxiMjKZjLatWtC9ow/dfdvT3PnR1iZJz8pm18HD7Dp4mGup6QC4ONjTvq07LV2caenqTDMnRwwNHjydMCEpmY1+fuwKPIBSqWRIv77MmjIZB/vqHPD7eVbWbljP8hU/sd9/D8b/wmJbQrQfIU+iOD0JPEl2UalU/Ll2Dav++hMjQyOef/Y5Rg4b/lDyfiOjovnyhx+5EqmgnUdb3njxBVo1b1ZrXEWFmsi4KH5fv4OT5y8iSRJe7nIG9uhG366dsDCrOwtDkiTyi4rJzM4lJ78AqP6TMDQwwNzECDMTY/TuI/4uSRKJ11I4GXKRU+cvciUqmsKi6sa9VpYWONnb4dzUjhYuTni5taaZk8N9lYnNys5mzeYtbNu1B5VKxfCBA/jf7GcxNjK6r2fl19W/s+qvPzlx8PC/omzt7QjRfoQ8SeL0JPGk2EURdZXFn39GVEw0A/v1581XX8f0IaSpZeXk8NOqP9i9/wBmJia8Ouc5hvTrW8tDLiouwW9/EJt27SUlPRNzU1PGDu7PyAF9sLWqWdRSrVZzNT6JK9FxhMfEExETT3JqOmVK5V3nY2psRDMHe5o52NPcqSnt3Fri6mB/Tx67JEmkZWYRFZdATEIiiddTSLiWQkLydQqKioDK0E1HLw+eGjoQb/fW9/xGkJmVzZ+bNrF15y5823nz7aIF2Nqa3fOz8vHihQSfP8+e7X739LnGghDtR8iTIk5PGo/bLpIksWHLJn5Y8TNmpqa8M/dNevXo+cDnValUbN7pz69r1lJWXs7E0aOYNWVSreJQOXn5bPTfy5Y9gRQUFdGujRuzJo3C260NOtrVudjFpaWcuRTO8ZBQTlwIJSev0mZmxka4NXfB1cEeawszrCzMMDcxQeOGSEpIFBSVkJtfQE5+PtczsohLuk5M0nWKSioXHS3NTPFtI6ejpzudvdrQxLxhWSu3I0kS19PSuRgeScjlCI6eCSa/sIgWLk5MHD6YIb17oq19b28tO/cF8Om33zFt/FMseP+1e3pWJEli2NjR+Pr4sHDeR/d6O42CJ7IJgkDwqMjNzWXxl59z/OQJenXvwQfvvIepickDn/dkcDDLVvxKQnIyXXx9mPvC8zg7OtQYk5aZxdodu9gRcJBypZJenXyZNnYkbeUtq/4QlSoVpy9dIfDEWY6eu0hpWTnGhgZ09mpDt/aeeMlbYGdleV9xbUmSuJ6eyfkrkZy7HEnw5UgCTpwFwKWpHT5t5LRp4Ypbcxec7W3RbEBoQSaT0dTWhqa2Ngzr24vSsmcIOHKCTbv28ekPK9kddJTP33sDc9OG23jk4EFcUVxlzeYtzJkxER3thldEjI6NITsnmw7tfRr8GUE1wtMWnnadPC67XLh0kfkLPyEvP59Xnn+RCeOeeuBFvYSkZJat/JWTZ4NxbGrPa3Nm071TxxrnTc/K5veNW9l18DCSWmJw7+5MHzcKF4fqbImCkgJWbdnH7iMnySsoxNTYiH6dfejX2Rfv1i0eSW0NSZKISkjiTGgE5y5HEKqIpri0DAADPV1cHexp5miPa1N7Wjg70LqZM6ZGDRNQSZIIOHKCJT/+goWZKV9+8DatXJ0bPLfjZ87y5kefsP2vX7C3aXhlvz/XruHnX1eya+t2mlj+O/umCE9b8J9gm98Oln6/jKb29nzz+VcPvPEiOzeXVWvXs233HvR0dXltznOMHzkC7VvCG3n5BazZvpNNuwKoUFcwakBfpo4Zgb2NNQBKlYqg0+fZuv8wlyKj0dTUpJevN8N6d6Wzp3stoVapKkjJyiY5LZPktExyCoooKSuntKwcZYUKfV1dDPV0MdTXw8bSHEebJjjaWmGkX3d9EplMRisXJ1q5ODFt5CAq1GoSrqcScSNmHpt8nRMhYfgfOlH1GVcHOzp4uDNuQC9cmtZf6U8mkzG4d3ecm9rx9mdLmfPeR/z+5WKaOzdMgG8Wuyq4ZfGzIZw6c4bWreT/WsF+1AjRFjx2lEolS79fxg7/nXTp1JlF8z/GyMjovs9XWlrK+m07+GvzZspKyxg5eBBzZkyrsUGkXKlkw849/LFlB8UlpQzq1Y3np0yoEuus3Hy27z/MtgNHycrNw9HOmnfnTKGXjw+WZtVhhLzCIkIiYwiNiicsOp7I+CSUqooa89HT0UFfVwctTQ1KysspLilDfdsbrq2lOZ4tXfBs6YpXK1daONjVmVWhqaFRtWA5rFfX6nkUFFYtgl6MjMLvwFE27wuip68X00YOxqNV83rt5dayOau+WsyMN97no6XL+WPpkgbFuDOysoDKLJWGolarUVy9yohhwxr8GUFNhGgLHisFBQW8/eH7XAy9xIynpzJn1nP3vdmivFyJ3759/LF+I5nZ2fTq2oWXnpmJi1O15yhJEkfPnOO71Wu4lppOjw4+vDhtUpV3mZqZxZqdAfgHHadMqaRrOw8mDO5LJ093bGxMycgo4Fp6FkdDLnPs4hUuKmKpUKvR0daitYsjEwb0oFlTWxxsmuBo3QRzE6Na4itJEsWlZaRkZpOUlklCSjpRidcJiYwh8PQFAMyMDfF1a4mve0t83FrgaNPkjmEiU2MjOni40cHDDYCc/AI27Qtiy74gjgRfZHD3Tnz4wowai6i3Ym1pwQcvz+GtT79i7Q5/Zo4fc1d7JyZX5qi7ODYlP7/8ruMBrqekUFJaQotm9X+JCO6MEG3BYyMrO5vX336TuIR4Fs7/mIH9+t/XeZRKJbv2H2D1ug2kZWTg3bYNS+a9j1ebmn0L45KusXTlaoJDL9PMyYHlCz6ko7cHAGmZ2fy2xZ/dR08BMLRnZ6aPHIyTvS1Q6VEH7gphc8AJLsckANCsqS1PD+lNd+82uLk6otPADAyZTIahvh4tHO1p4Whf9XNJkkjJzOaiIpbg8CiCw6M4cPYiAFZmJrRr3Zx2rZvj1dIVV3ubO+Y3m5sY8/yEUUwbOYi1/oH8tsWf7PwCvnjzRQzqKRXbo6MPXX3asWVPIFPHjrzrDs60jEwszc3R1dUFGibaubm5ADRpIkIj94sQbcFjITUtjf+9+ToZmZks/ewLOnXoeM/nKCsvZ/f+A/y1cRMpaem0aS3nw7mv0bF9zXrZRcUl/L5xKxv892Kgp8dbc2YyZvAAtDQ1KSgq5s8de9i49yCSBGP792TqyEHYNrEEIDw2kY2BRzlw9hKqigqaO9jyyoTh9Ovohb2V5UOzB1SKub2VJfZWlgzt3gFJkkhISSdEEUNIRAznI6KrPHFjA308Wrrg69aSzh5ymjWtu5CUgZ4es8ePxM7Kkk9X/Mkri77h+w/nYlTPbsmRA/rw3uffcOZCKN1871waIDsnB0uLe6ugWK6sFPf6PH7B3RGiLfjHSU1L46XX/0d+fgHLl36LR5u29/T5ktJStvrvZt22bWRl5+DeqhVvv/IyXTv41hAuSZIIPHqC5X+uIyMrmxH9e/Py9CmYm5pQoVazbf9hVmz0I7+wiCE9OjNnwijsrCyRJIkj58P4e88hQqPjMdDTZWzfrkwf2Zsmxma1xFGSJLILikhMyyI5PZuM3AKyCwrJyiukqLQMpbKCMpUKSS1hoKeDob4uRvp62FqY4mzbBBfbJjjbWKKnW3NXpEwmw8XeBhd7G8b26YokSSSlZRIaFUdoVByXrsbx/aUIvt9Q6Yn36eDFlMG9sGtSO8Y8vHc3jA0NeP+bFcz//leWvvNKnZ56d9/2GBroc/TsubuKtlqtvu/djI8ya+3fjhBtwT9KZlYmr7zxepVgu7Vu3eDPFhYVsXXXbtZt3UZuXj4dvL1Z+O7b+Hh51RLSiKgYvvntT0IjryJv7spn77yOR+tWAFyOiuWrVeuIjE2gvbuc16dPQO7qVFk7+8IVft2+D0XCNeytLJj79GiG9+iIkb5eVRpXXlExoTFJhMUkExaThCIphcKSshrXN9LXxcLECCN9XXS0tTDU1UGmIaO4tJzs/CIKikvIyCvgpnZpamjg5myHd0tnvFs40V7uUiujRCaT4WRrhZOtFcN7VL6ZpGXlcOaygpOhkWwNOsHWoBMM7uLDrJEDcLCpGYLo1aEdb8ycxFer1rFu936mjhhUy8ba2lq0b+tO8KWwu/4+rJpYEhUbd9dxt6KvV+nhl5WV3WWkoD6EaAv+MQoKCnj9nbfIysri+6XfNFiwS0tL2eTnz5pNm8kvLKSLrw+zpkzGs417rbHXUtNYuX4z+w4fx9zUlA//9zzD+/ZCQ0ODvIJCfly3Db+gY1iZm7Ho1dkM6FpZyjUsOp5l6/y4HJOAg7UlH82ezKAu7aviupl5BQScD8PvSAghinjUkoSmhgZyJ1sGd/LE2bYJTjaWOFpZYGVujG4DXv9Ly5Ukp2eTkJaJIjGFC1GJbAw6w9+BJ9HUkOHR3JHO7i3o5N4MuZNdnTFmG0tzRvbqzMhenUnNymHt3sP4HTlN4OkQPpo9hYGda3rL4wb2JjgsgpUb/ejbyQd769qx5Y5eHhw7e55rqWl3LP/a1NaOrJwccnLzgIZ53DdrnJcK0b5vhGgL/hHKysp4Z977xCcksPTzLxsUElFVVLBjz15WrVtPVnYOXTt2YM60p3Fr1arW2MzsHFZt2s6OwINoaWowfexIZowfjZGBAWq1Gr+Dx/hx/TYKi4qZMmwAz40fiaG+HunZufy4eTf7Tp6niZkJ7z8znuHdO6KlpYkkSQRHxrLx4BmOhSqQJHC2sWTGkO50cm+Ou7N9rZDGvaCno00LBxtaONjQz6dy0bRMqeRybDJnwmM4fSWGFX5BrPALwlBPl3atnPGRu9ChtSstmtZeiLS1NOfNqWOYMbwf8376i/k/ryEtO4epQ/pUvYnIZDLemDmJ8XPn88PaLSyZ+0Kted1cnD1zMYyxg+sXbR9vL6Q/JE6cOUen9g1bk7iZGaS+rSu9oOEI0RY8cpRKJfMWfsKFS5dYOP/jBpVTvRKp4PPvl3M1JpZ2Hm35bN4HtbJBAFIzMlmzbSf+Bw6hqlAzakAfZk0YW5U7fDkqlm/+2MCV6Di8W7fk7Wen0MLJAaVKxZ+7DrJ6534q1GpmjujPjOH9MNDTRVVRwa6TF/g78CSx1zMwMzJgxuDuTB7cBTM9g3veoalWS5SrVChVFVX52vWhq62Nj9wVH7krL43pT3Z+IeevxnMuMo7ziniOh14FwNzYgA5uzRjZrT0dWrvWmFMTMxO+f/sFFvy6jh827sJQX4+xfapzum2aWDB95CB+3eKPIi4RuatTjTk4N7XHpoklZy6GMnZw/Rk97q1aYmJkxNFTZxss2jfnKWLa948QbcEjRaVS8fHihRw7cZy3Xn/jrml9hUXF/LR6Ndt27aGJhQVL5n1A3+7dagll4vUU/tzix97Dx5DJYGjvnsx4ahQOdpUpemmZ2fy0fhv7jp/B0syUj196hiE9uyCTyTh75Spfr9lGQko6Pdu35fXJo2hqbYlarebg+Sv84neI+NRMWjrYMH/GKAZ2bIuutnadW5MLS8qIT8vmelYe17LyuJ6VR2Z+EVl5hWQVFJNfXEqZUlXjM7raWhjq6dDU0pRmdk1obtcEuaM1bZxsa6UNWpgYMcC3LQN8K99M0nLyOBcZx9mIWE5fiSbw7GVaO9kxbVA3+rR3qwqh6GhrseiFqRQVl/LN39txc3HEzbU6X33CkH6s8Q9gS8AhPnxhRo1rymQyOrf3Yv+xUyiVqno32mhqatLey5OTZ88jvSQ16MuspLSyGJb+P9yh/t+EEG3BI6OiooKFny8h6MhhXnv5FZ4afecNG1djYnh/0RKup6UxftQInp8+vVbj3MTrKazauI2Ao8fR1tJi3OABTB0zHJsbZVILior52z+A9bsPIElqnhkzlGmjhmCor8f1jCyWb9xFUPAlHKwt+eaN5+jmVRkXD1HEs2xLAJEJKbjaWfHFixPp7V2zdGmZUkXw1USCryYSlZxOdEomaTk1RdzC2AArUyOamBjS0sEaUwM99HS00dPRQlNDg9JyJUWl5RSWlpGUnsvh0Cj8TlUu+unpaNG+hSMd5c50au1MM9vaRadszE0Z1sWbYV28KVeq2HsmlL8DTvDhr1vwau7I8rnT0bvRaUdDQ4NPnp/C1PlL+fyPzfzxydyq85kYGTKoeyf2HTvD3JkTa+Vud/dtj19gEBeuRFSFS+rC18uLwydOkpqejp3N3dufFd3Y8q6v/+ANGv6rCNEWPBIqKir49MvPCTywnxdnz2Hy+Il3HL8rcD9fLv8DJb2UAAAgAElEQVQRE2NjVnz9Ra1QSGZ2DivWbmR30BG0tbSZNHIoU0ePwPJGudLSsjI27Qtijd8+8ouKGditIy9OGoO9dROKSkr5afNu1gccQUOmwZyxg5k6pA+6Otpcy8hm+db9BIVEYGthysfPjGZwJ8+q6nklZUoOXrxK4PlILsYmU1quQlNDhqttE9o1d6C5nSWutpY0bWKGvYUp+rr3ln8sSRJZBcVcjr9O8NVEzkQmcDK8MiPDytSIjnJnOrs506m1C2aGNYVOR1uLUd3bM6KrN/4nL7JkzU4W/rGDxc+Nq4p3mxkb8cyI/nz511Yi4pJwb1YdChnYtQN+B48RHBZJrw7eNc7t49EGTQ0NQq6E31G0m97YfJSZndMg0U7PqOy0Y9Xk4bVH+68hRFvw0CkvL2fBksUcPHyI2c/MYsbT0+odq6qo4JufV7DVfze+3l4sev/dGjVClEoV63fuZtWmbahUFUwcPoRp40ZieWOMUqXC7+AxVm/fTWZOHt3ae/DCxDG0cnFEpapgW9BJftsRQFZeAUO6+vLi+KHYWJhRUFzCSv/DbDh4Gk0NDZ4f1YenB3St8lIVSWlsOxFKYEgkRaXlODQxY1JfHzwc7WjXwgEjfd2HYiuZTEYTE0N6e7akt2dlgayU7HzORMZzVpHAscsx7D57BQ2ZDM9m9ozs7MHQDu5oaFR74BoaGozq3p78ohKWb91Payc7pg/uXnV8UJf2fL/BH78jp2uItlfrlhjq63PiQmgt0TY00Efe3JWLVyLvOH9jw8oaMQWFDatol5KaCoCtrW2DxgtqI0Rb8FApKiri3fkfcC4khFdfepkpEybVO7a0tJR5n33JsdOnefqpcbw0a2aNtDZFbByffPsjsYnJ9Ozky2vPTK2KWVeo1QQcO83KzTtJycjCu3VLFr82h3ZurVCr1ew/c4EVW/eSnJaJZwsXvnxtFm2bO6NSVbAp6Ay/+h8mv7iEIZ29eGl0P6zNK4tAXYxJZnXgGU5FxKOno0Ufr1aM6uJBu+ZNsbY2qbfcpqpCTVpeIdeyCsgpLCG/pIy8olKUFWo0NWRoamqgp62FvYUxDpYmOFiaoK9Tt1duZ2HC6K6ejO7qSYVaTXhCKqci4jh44SoL1+5jT3A4H00ZhK1FzfrXUwd25Ux4DFsOBzNtUPU6gJGBPu1aN+NKbGKN8dpaWrg1dyY26Xqd83CwsyE8Krbe3x9Abn4+UC3edyMqOoqm9vbo6T6cL73/IkK0BQ+NzKxM3nj3HWLiYvn4g3kMGVh788ZNCgoLmTvvYy5HRvLWyy8yfuSIqmOSJLFx116W/7EWcxMTvv7wbXp0rC6YfyHiKktXrycqIRm5ixPvPjeVzl6V4ZTTYZH8tHkPioRkmjvYsnTus3TzckeSJA6cu8IvfkEkpGXhI3fhtacG0tq5svZHSHQyv+w+wYWYZMyN9Hl5RHfGdfeu06POLiwhIikDxfVMFNcyiUnN4XpOAaqK2mlsmhoyKtR1Z0q4WJvRztUW3+ZN6dCyKWaGtRfnNDU08HC1x8PVntlDuuJ3Koxvtx1m8ud/smTmcLq4u1aNlclkDO3sxSertxMWm4Rn82qv2tXehpCIaCrU6hqNE2ybWHL60uU656eno0tZ+Z1risQnJQHUaiZRF5IkcSUiAm9Pz7uOFdSPEG3BQyH0chgffDyfoqJivl7yBV06dap3bFFxMXPnfUxEVBRLPnyfvj2qX+XLysv5/Kff2HPoKD07+TLvlecxNans1p2TX8Dyvzez+8gpbJtYsOjV2fTv4ouGhgaXYxL4cdMuQiJjsGtiwcezJzOoqw8aMhnHLin4ZechopLTcLWzYunLk+nu2QqZTEZo3HV+2X2C4KuJNDEx5M1xfRjVxaMqTAKgVFVwPjaF0INpHA6NIzolu+qYg6UJLe0s6OPhWuVBWxjpY2qoh4m+LlqaGkiSRIVaorhMybXsfJKz8knMzONyQhqBF2PYfiYSmQw8nW3o4e5ML3cXnK1rtxaTyWSM7upJh1ZOvLFyB59t3M/W+c+irVX9dtK+VWUTg5hr6TVE29TIkDKlCqVKheYtTYR1dbQpL6+7h2VeQWG9xaVuciE0DMemdpg0oKN6fEI86RnpeAnRfiCEaAseCEmS2L7Tj2+Wf4ettQ3fffUNzZvV7mZ+k+KSEl6f9xHhCgWLP3ivhmAXFhXz5uIvuRgeyezJTzFrwtiqBbWj5y7y6Yo/KSguYfqoIcwaOwx9PV3SsnJYvnEX+89cwNzEiLemjmF0ny5oaWpy+ko0K/wOEZFwHUdrCxY+O5YBHdqiqaFBeEIqv+49yYnwOCyMDZg7pjdjunlWibVaLXEpIZWAC9EcCI0lv7gMHS1NPJxteHFwB7xcbGllZ4mR/t0318hkMrQ0ZZgY6GJiYIWbQ/UinKpCTeS1TE5GJnIsPIEf9pzlhz1n8XKxZWYfb7q5OdU6X9MmZrw+uhevrdhGYEgkwzpWL9reDC/dXq87v6gYXW2tWl3fs3Ly6u09GR4VjY9H7dz4mxQWFXP2wgWmTxx3VxsAHDp6FICe3Xo0aLygboRoC+6b0tJSln6/DP89u+nSqTML5n10R49LpVLxweIlXImIZNH779YQ7OKSUl5f8BkRMbEsevNVBvas3AyiVqtZuXknq7ftRu7ixE8fzaK5U1NUqgrW7Ani9x2BqNVqZo0awLShfTHQ0+VcZBw/7zhIWGwydpamfDh9JMO6eKGlqcnFmGRWBZzhdGQ8JgZ6vDyiBxN6tqvK+sgpLGFnsILtZyK4nl2AnrYWPds4M8i7BYM7yynKL63z3gpLlWQWlJBdWIqGhgxdbU30tDWxMtbHSK9+YdfS1KCtkzVtnayZM9CX1JxCDoTGsPVUOHNX7+Ppnp68PKRjrQ05nd1cMNLXJSwupYZoF5ZUzu/2bfRJaZk0MavZxV6SJKISk2nmYM/tXI2NJyM7B0+32rtPb3Lw6FGUShVD+vWud8xN1Go1ewP34eXhiZUoy/pACNEW3BdxCfHM++RjYuJimTl1OrOfmXXH5gWSJPH59z9w6tx5Pnj9Vfr1rPa2SsvKeevTrwiPimHx26/Rt2tlaKWopJT536/kREgYI/p0451nn0ZHW5v462ksWLmO8Lgkeni34Y2pY7C3siDmejo/bN3PibAorM1NeO/p4Yzo5o2WpibBVxNZFXCakOibMesePNXDG8MbghqelM76Y5cJCotFWaGmfTM7XhjoS882LhjcEHQDXW2KKCUjv4SLiRmEJWVyOSmL2PQ8istVtW/6Bo6WxrjZm9OmqSU93ZrS1Lz+RTtbcyOm9vJiYre2LNt1irVHQ8kuLGbBpL41xslkMjRkMjQ1a+Zxh8UmA9DGtbq3pVKl4lx4FIO6tK8xNiohmWtpGUwfNbjWPHYeOISOtjYDenStdQwqf5+bd+6ihasr7TzbkJlZWO89AZwLCSEpOZlnZzxzx3GCuyNEW3DP7D94gCVffYmeni7Lvvyazh3rj1/fZM2mLfgHBDJrymRGDakWCbVazSff/kDI5XA+ef3lGoL9+pJlXImO461ZU3hqYG9kMhkHgy+x6Nf16Ghrs+SVGfTr4EVpWTnfbtrHpqAz6Ovq8MrY/kzs1wldbW3OKhL4ZfcJwuJTaGJiWCMMUq6qYM/5q2w+eYUrSRkY6mkztrM7Yzu74WpTs050QmY+W0Ni2BUcw5VrlTFtXS1NWtubM7ydKzamBlgZ62NhpIckQZmqglKliuTsQiKv53ApMZPAsESWBVygh7wpEzu3wtfVut5dhNpamrw9ujuGejr8EXSRZ/q2x+WWOLdSVUFJmRK92zzqM+ExmBrq42xTXev75KUIikvLqjYS3STwxBk0ZDJ6+HjV+HlxSSkBR47Ts5MvJvW0fQsJDSMqNpb3X3u1QTshd/j7YWxkRJ+eve46VnBnhGgLGkxpWRnf/bCc7f5+eLb14NNPFjboVdc/IJAfV61mQO9ezJk+tcaxles2c+jUWV6bNY3BvSvDJSWlZbzx+fdciY5j0Wtz6NfZB0mSWLFlD6v9D9C2uTOf/28mVuamhMUmsWD1DhLTshjTw4cXR/fFzNiQ8IRUfvQ/RvDVRGzMjXlnfD9GdG6LrrYWmQXF/HX4EttOR5BdWIKzlSlvjurKMJ9WNUIZ+SXlBIYlsOtCHOE3hNrN3oIX+3nQqYUdrWzN7lhH5Hau5xSyMySWbcExHI28RlsHS14e4ImPa/2bUvq0deWPoIvEpefUEO3LCSkoKypo61LduDe3sJhDFyIY09Onai1AkiTW7DmEXRMLunhWV1UsLC5m2/6j9O3sg+VtYRO/wIPkFxYxaeTQeue1ZtNmzM3MGNyvz13vOyExkUNHjzB9ytM3utwIHgQh2oIGkZqWxjsfvs/V6CimTp7CC8/OrtWJvC5OBZ9jybLv6eTTno/feqOGV3bwxGlWb97OqAF9mXxDIFQVFbz/7QpCFdEsfHV2lWB/9ddWtgadZGTPTrw9fRzaWpqsDTzJ8q37sTY34ac3ZuDb2pXCkjIWrQvA//RlzAz1mTumN2O7e6GrrUVSZh5/BF1g34VolBVqurV2YlL3tnRs2bRGIaOwpCy2Bkdz8Eoi5So1LWzMeG2QN+N7uqFTcf+FjuzNjXihnyfP9GzDnktx/H74Ci+uPsSL/Tx4plfdC3525pVrBNeza+aHn46IRyYDn5bV9UR2Hg9BqapgdPdb0iMVMYRFx/PW1DE1cuA37g2iqKSEaSNrhkbKystZ67eb9m3d8ZC3rHNOV2NiOXXuPC/OnNGgfOvf/liFjrY2E5+acNexgrsjRFtwVy6GXuL9j+ZRrlSy9LMv6Nal7jjn7cQlJvLhks9p7uLC5/M/RPuWV/nE6yksXv4LHvKWvP38rCrR/GHtFk5dvMz7c6YxoGtly63lG/3ZGnSSaUP78PKE4aglic/X7mL70fP0be/GvBmjMNLXI/hqIovW7iM9t5Dp/TvwzMDOGOrpkJCRy6qDFwi4EI22pgajO7VmQre2OFtVe64FJeXsC01g+7lootPyMNTVYkS7Zoz2bY7crjJUYmVhVLW5pkxVQXxmIbGZheSXlGNjoo+dqT52pgaY6N95K7uutiZjfFswxMuFxTvOsiIojJa25nSX114QzMyvrNVhaVxdg6VCrWZPcDgd5c6YGFSm5JWUlbN2/0k6uTWjhUOl5y5JEj9s2oWVuSkjelaHsLJy81jjt4/eHdrRuplzjettDzhARlY2n7z+Ur3z/3PDRgwNDBg34u4d1U+cOsn+oIM8O+MZLMzvrTWZoG6EaAvuyM7du/jim6+xt7Pjq08/x8XZ+e4fAjKzsnnrowXo6ury9YKPMLilQFBZeTkffLkMbS0tPn37taoqcruPnGT97gNMGNKP0f16ArBmTxBr9x7mqX7deHnCcCRJ4pNV2wk4G8aMwd15aUw/AH7ceYw/D5zFydqc3+ZOpq2LHaVKFcv8T7Hh+GW0tTSY1L0tU3t70eQWAYxKzWXDKQWBYYmUqSpobW/OB6M6MLCtU9UC5E1KylVsC0lka0gC0en51LNnhpFeDnw4zBONu8R69bS1mDeqI/EZ+SzecYbdb4+qsfEFIDolC4AWttUtxM5GJpCWU8Bro6vjw5sPnSWnoJjZI3tX/Swo+BJXYhL58NmJNep+/7xhO0qVilemPlXz/kpL+WOzH76ebfD1rLve+bWUFIKOn2DKuDEY1xPvvklubi5ffLOU5q7NmDm1/lIGgntDiLagXjZs3sSyH5fTuUNHFn+8AKO7/JHeJCsnh5fffZ+snByWf74EW2vrqmOSJPHFz78TFZfA0vnvVFXni026xhe/raW9u5zXpo0Hqnc39u/kzZtTxyCTyVi+dT8BZ8N4cXRfnhnakwq1ms83HsDvVBhjunoyd2xv9HS0uZyYzoKNh0jIyGNsZzdmD/Cp8lbVaonT0SmsPakgODYNPW1NhrVzZbRPM1rb1+6vmFlYyobgePwuJpFbXI7cxoRZ3VrSzMqIZlbGmOnrkJZfQmp+CWfjMtkakkgTIz1e7C2/q630dLQY6OHMD/svUa5So69TU7SPRSRgZqhXI5694UgIFsYG9GzbHKhM8/sr4ARd2rSo2lBTWlbO9xv8aeFox7Du1fXLw67G4H/oBFNHDMLR1rrGtTbvDiAnL4/np7xR73x/X7sebS0tJo0Zfcf7kiSJBZ99Sm5uLl8uXlLjLUvwYAjRFtTJylV/sOzH5fTu2YuF8z6qahN1N3Lz8njl3Q9ITU9n2acL8XCr2VJsy54Adgcd4dmJ4+juW5mCVlpWxgfLfsFAX5dFrz6HlqYmKZnZzP95Dc0dbJn37EQ0NDTYcvgsfweeZHzvDswc0gO1WmLh2gD2Bofz7KDOzBnaFZlMxl+HL/LT3mCsTA34YfZQOras3mJ9KDyJFQfDiMvIx9pEn5cHeDHapxmmBrVjs6XKClYevcqmc/EoK9QM8nRgjKcj3o7mtTImLI10cbc3o4/cFpVaYtWJaFrZmNDPza7Weevjdr+8qLScY+GJDGnfsmrBMy41i1MR8Tw/tGtV7e2NB8+QX1TC86OqFwX/3nOI1Kwcfp7zUpX3rlarWbp6PVbmZswaN7zGtYpLSvl7+y66+Hjj6Vb3l01icjJ7DwYxcfRIrCzv3Il+w5ZNnDpzmrdem0tr+d2/vAQNR4i2oBaHjx3li6XL6N+nL598OL9BC45QvT09+fp1vl28gHYeNUt6XgyP5Nvf19C9Q3uem1S9i+77NVuIS07h+w/n0sTcjAq1mgUr16GqUPPF/55BX1eXqORUvt0UQLe2LXlj0hBkMhm/7zvF3uBwnh/alWcHdwHgj6AL/LQvmP6ezfhgXM+qHYv5JeV8tfs8AaEJNLc2ZcG4zvRv41hjC/itKFLzmO93kbjMQoZ5OvBstxa0l9vWWzDqJjKZjHcHtyU4LpN9l681SLQTsvIx0tNG57a57D5/lVKlihEdqkVv/eHz6GprMbZbZZpeQXEJ6w6coqeXHHeXytzs1Kwc/tp9kP4dvWnfukXVZ/ceO01EbAKfvPIshrc1DfYLPEheQQHPThhb7zy/W/kbenq6TJsw/o73c+BQEN//9CO9uvdg3F1qqAvunQcSbblcPh8YRqWTsFuhUCx8KLMSPDaioqP55NNFeHm0Zf57HzRYsAuLipk7bz6K6Gg+/2gevt41S31mZGXzwZfLsLexYsHcV6pS0g6cCmbr/sNMGT6QTp6VecTr9x3hgiKW+c9NwsGmCWVKJR/9tg0TA30+fmY0mhoaHA2LZuXekwzt6M6sQZ0BWHc0lJ/2BTO4XQs+nti7ysM8H5fGx1tPk1VYyvN9PZjRw63eVD1Jkvj1WBSrTkRjbqDD8skd6dzs3mo/a2tq0MzKmOt5JXcdW6FWcyzyOl1b2tUot6pWS2w8frlqtyRAVn4Re86GM7xTW8xvhHo2Bp2hoLiU2SN6V312xZa9APxvUnURrpLSMn5ev502LVwZ1K1mazClUnUjY8StqmP97ZwMDub4mbO88twsLO+woHgm+CyffLoIz7YeLJj30T23ZhPcnYYnmd6GXC7vBIwFegI9gBFyubxhaQWCJxJJkvhy2VIMDQxYsfzbBufUlpSW8sb8j7miuMriD96jZ5fONY4Xl5Ty9pKvKS4p4Yv33qzqRpOcms6nv/yFR6vmvDy50iNLSstg5ba99GzftioW+9e+E8RcT2f+jFGYGRuSV1TCp+sDae1gzfsTB1S2EItK5rvdp+nr4cpHE6oF+0pyFq+tOYKBjjar5gzg2d5t7phb/fvxaH49FsUAdzs2zOl5z4J9E1N9bfJL6i7EdCvHFNfJLS6jX5uaNUYOX4kjKSufyd2r31Y2HglBWVHB5D6VYaWC4hLWHzhNTy85cqdKjz466Tr7Tp1nwoAe2FpWi+vf/gFk5OTy+vQJtRoC7wo6TEZWNjPG1R2nLiwq5ovvf8DJoSmTRo+q916uRkXx3vx5uDg78/WSz9ETLcUeCfct2sAQwE+hUJQrFIpywA+oPxtf8MRz6uwZwi5f5rmZs7C2aphYlZWX886CRYRFRLDovXdq1BOBG/VGvvwWRWwci958lebOlXnFSpWKed+tRFNDg8WvVeZ8q9VqlqzahKamJu9MH4dMJiM5PZs/9x5jYIe2dPWozBv+3u8o+cWlzH96MLraWuQWlfLR+kO4WJvz8cTeVaKcW1zG+xtPYGmkz8pn++FWxyLjrQRFpvDL0asM9WjKwpHemDagGFR9ZBWVY2F498+vO6nAzsyAHrek+0mSxB9BF3G0NKGvZ2Xp1YLiUjYfu0hfr1Y4W1fex4aDlV72nFsyRn7Ztg9DfV2mDave9p6encOanQH07+KLp7w6XAJQrlSyetN22spb0qld3dX3fvx9FemZWXz01pv1LihmZWXx9ofvYWxszLIvv8a4AVX/BPfHg4i2PZB6y/9Tb/xM0EhZt3EDtja2DB/SsO9etVrNwq+WcjbkAvPeeL1GPRGoFJ+vV/7BqZBLvPviczVqYq/ctJOI2ATmvTAD2yaVi1q7jp0lJDKG1yaPxMq8cpfe8q370dLU5LXxAwGISEzD//RlpvTxpWXTyi+WVQdDyCsuZdHkvjUaC/xxNJyMghI+m9gNM8M7vzVIksQX+67gbmfKB0M9Hvi1Pim7CGuTO3uaIfHpXEzIYFJneQ3v/0RkEpHXMpnW26vqjWH94RCKSst5ZmBlvnVeUTHrD5yil3drWjlWetlh0fEcDbnM04P7YGpkWHW+FRu2o1areXlK7Xj11r37ScvMYs6U8XXe8+nzIWzbvYeJo0fWWlS+SX5+PnPfe5u8/Hy+WvIZTSxFQahHycNciJQBNTJXzc0N0KpnoedJwspKeAW5uXlcuHSRObNmYH/DI72bXZZ8+yMHjh7jvddeZOaU2gtOf23xZ3vAAZ6f+hSzn65+9T57KYK//fcxaVhfxg+rzDXOLSjipy178G3Tgueeqgx5XFAkcOhCBHMnDcK9ZeUi2zur/DAz0uftKf0wNtAjr6iUncEKRnZ2o5uXS9U1KtRqDl5Joq+HE728755bfj2niOyiMl4f3BYHu7pLlTbEJgBxGQVcyy1mTr/W9Y6XJImffj+Inbkhc4Z4o6ejVTXvFYHBuNiYM3OwD9pammTmFbL+8HkGd3SjW7vKNL8/Ao5RVFrOezOHY2VljCRJ/PLlXpqYm/C/qcMw0Kv8klLEJbHn6GmeGz8MrzY1S+bm5OWzatNWenZqz7D+XWuJdlZODou/+YZWzV2Z/9Yr6OnV/uIrKSlhxuwXiYuL45cfvqN7V59aY/6rPCpdeRDRTqKmZ20PJN86ICen+AFO/89gZWV814yA/wJ7AgKpqKjAx7sjGRkFd7XLzoBAfluzgfEjRzB6yPBaY89eDGPhsl/o0dGHmePGVh0vKCrmfwu/w8HGmjnjx1T9fOnf28gvLOb1SaOrKsZ9umonliZGjOranoyMAiIS0zh8MZqXR/SgtEhJaZGSDcfDKC5T8lQntxpzCL+WTVpeMT1a2DXo9xscU9lw1lpfu97xDX1W1hxWAOBpY1rv+B3nYghNyOCjMR0pyCvh5qi1R0K5ei2Lz6b2J/fG388Xmw5QUqZk1oBOZGQUkJGbzyr/owzwbYOlQeUuzaMhlwm+EsW7M56iqKCcooLKjjNfrFiHvp4u4wf2qzWXr35ZTWFRMS9OnVyrSl9FRQVvfrSAvLwCvl20iIKCcgoKanexWfjZp4RcvMSnHy/AvbWn+Fu6wYPqyp0E/0HCI7uB0XK5XE8ul+tRuSjp/wDnEzxG9u0PxM7WDnc3t7uOjU9MYumPP+Pr7cXcF+bU8tBS0jOY9/X3uDg0ZeEb/6ux8PXdmk1k5+Wz8NXZVWlnqVk5bD90iuE9OtLSqdIPuBybzPmr8Uwb1K3Ka9x+8hK62lqM615dle5czHUcLU1oaVczb1hf597e8JqaVS6Oxt+lxOjdiM0o4K9TMQxwt8PB3KDOMVeSs1i6J4SOzWwYcsvbQWhCGj/sPUOvNi709aiMZYfGXmPbiUuM7+mNy43KfT9sO0CFWs0Loyrj1ipVBcs3+uNiZ83IW7arX4i4yuHgC0wbMQhT45oboy6GR7JlTyBPDR1EMydHbue3v9dx6tx55r4wh5bNXGsdB9gTsI89Aft45YXZ9O1998JRgofDfYu2QqEIAdYAR4EjwBqFQnHuYU1M8M+RnpHBuZDzDB4wsFZmwe2oKir46Isv0dXV5ZN33qpVQ7uiQs0HXy5DVaHii/ffxOCWfOCQcAX+h07w9IiBuN1S8+JP/4MAzBo1oOpnfweexMRAj9E9bmzAKVcSeD6S/u3kNfo2Xk5Ix8OldpU8ezMjZDKITstrkA2cLAyxMdHjeHR6g8bXRUpeMfN2XMRQV4u3BtZdAComPY+31h3DwkiPReO7VMWsU3MK+eDvA9iYGfHRhF7IZDIKS8pYvD4QazNjXhhWucB7MSqBvadDmdK/Cw43FiR3HDlNYmoGr0wcURWOrFCr+e6vTVhZmDFl+IAacygsLmbx8hXYWVvx4tTajZePnDzFqnXrGTagP2OG1b2+ERcfx1fffkM7Ly9eeWHO/RlMcF88iKeNQqH4SqFQdFQoFJ0UCsXXD2tSgn8Wv13+qNVqhg6qXQz/djbt8EMRHcO7r75S5664HYEHCI+K4b0XZ+NkX72xRJIkftnoh5W5Gc8+VZ0/nFdYxJ4T5xjc1acqRS2/qIRjoQqGdfWu8rLDE1IpLlPS17tm5bkypQqTOprv6mpr0rWFHdvORZNdWHe3mVuRyWSM8nLkeHQ65xOy7jr+ViRJYldoMpN/Pca13CIWjPTGoo6Fz+DYNGb/dgCZDL6d2hPzG41803ILefEXf4rLlHw5fQDG+rqoKtTM/3M3SRk5zJ8yCEM9HYpKy1iwegd2lmY8M7Ry0TiI9UUAACAASURBVDczN5+ft/y/vbuOjuJqHzj+3c3GFeKBQHwihEBwdylaQd4Wq0CVUm+xX10obaGlQoW2tIUiLa7FPViAQGzjEOLum83K74+kgbBJoBTekDf3cw6Hw8zscDOZeXbmznOfu4MuAT707XStXvbv2/cSk3SZOVMn1qnEp9PpeO+L5aRnZvPmC8/U+VIFiImP581Fiwnw8+X155+r9+VkcUkJry2Yj7m5Oe8sfOuWc/mFO+NfBW2h+auqqmLL9q307N4D97aNz6idlZPL97+uok/3bgzu28dgfXFpKd+uXk+X4CCG9etVZ935mDguxMYzffzIOvMUbj18CpVazX+G969dduBcNFUaLSN7XEtBu5SSDkCwR90RhpZmJpSq6p8xfM7ITlSoNXyz72KjP9ffpvXyxs3OnEW7LlFQVnnT7fV6PZfSCnj1j3De2RaBn5MNv8/qTx+fujU9tDod607G8cJvh3GyseCnWcPwcqrOjolLz+PJ5dsoLFfx5cxR+Lk5oNfrWbLhAMejk3l1whC6S+2ry9Ou2Ul6XgHvPP4AFmam6PV6Plu1CXWVhrmPTqgNsElX0/l+/WYGduvMsN7d6rTl1w1bOHTyDLMfnUJoh7qTImRkZfHqm+9gZ2vDZ++8VW/ZVb1ezzsfvk9mViYfvfveLaeGCneO+Ips4Xbv3UNuXh7zX597021/XbeeKo2GV597pt47sB37D1NcUsqcx6YarN9y4BjWlhaMG1I3LXDXibOE+Hni437tnXZYZAKu9rb4t7sWoNPyimhtbYGdVd1+Yg8nOy4kZ6LX6w3+T09HWx7uJbHqeCw9vF0YFmw4Se71zIyNmD+qIy+vO8O0n47x9ACJQZILlqbXLhO1RktiTimHlJnsjkojvbACc2Mjnh/sz5QeXhjJ67bh4pVcPtkRjjKjgN6+rrw3oRfW5ibodHrWHL3EN7tPY2NhytezxhDo7linANbUIV1r++9/2nmEnWERzBo7kE6+1V1Lmw6GceBMBM9MGEW7muJPFapKFiz9Dktzc16fWff3sPPgEZavWsfw/r1r65f/LTcvn9lzF1CpVrPso8XYt64/p33D5k0cDzvBS7PnEBIsZlVvCiJot2BarZZff1+Fn68vvW4yZVhefj5bd//FqKGDcXNxMViv1+vZuHsfwZIv/t51X1yVq1QcOn2OkX171rnLvpKZTeLVTF66Lh1Qp9NxPv4yfYJ96wSccpW6dj7H643s7Mu76w8RkZJFJ0/Ddj0zJJhLqbm8t/kU7R2t8XNpvKZzD08HVszozce7I3lnWwTvbovA09GKdq0tyShWkZBVjFanRy6D7p4OzOrnx0DJGasbyrim5Zfy0+Eotp1PxsnGnA8n9WZIkDsymYzL2YUs3nycMwlpDAjyYMGE/thZmlFYWs5bv+0iLCaFx0f05KlR1QOMt584z3dbDnJfz47MHFOdIhmVeJklqzfRq6M/02sG0uj1ej75aTXJaRl8Mf9F7O1satsTdu4C73/5HV2Cg/i/OXW/dAsKi5g9dz75BQUs++gDvD086j02iUlJLPvma3r16MmkhybUu41w94mg3YLt2rOb1KtX+fCd9246mGTX/oOoq6qYOqH+izXh8hWupGewYLbhS6nTF6NRVaoZfkPNi+MXYgAYEHqtdvPVnAIKS8tr7yb/Vh0oDds4ONiTpdtO8OP+cyx74j6Dn8NYYcRHk/sw49s9vLL6KD8/OQwHa3OD/VwvwNWWFTN6cTo5l6j0IqLTC0nKKcXHxZbeng74ONvQpZ099laG3QfRaXn8diyWg9FXkctlTO3jz8yBQViYGpNZUMoP+8LZcTYOcxMF8x/qz/juEjKZjAMX4vh4/T5KKiqZ/59h3N+7+i72j4On+XTtTrr5e7Jw+jhkMhlJaZm8vHQFDnY2vPPUlNqXx9//sZUdh8OYOWFsbR0XgKOnw5n38VK827mzeN4rmFw3qjErO4c58xeSkZ3N0vfeaXAATV5+Pq/On4uVlRUL35gnaoo0IRG0W6jS0lKW//A9gQEBtzTZ6qHjJ5B8fGjvXn+/d0R0dW5yfcXzz0TGYmZqQkfJu87y8JgE2jo74Opw7VE8/mr1IFs/97p3za2tLSgoNSzAZGFqzMyhXVi6LYyj0ZfpH+RhsI2DtTlLpvbnyR/38/KqI3z7+GCDCQ5upJDL6e3tRG/va/3TDeXeqjVaDsekse5kHBdTc7EyM2ZqH38m9fTFycaCjIISvt51is2nYpHJZEzu24FHB3WilZU5V3MK+XLrEQ5GxOPf1omvZ0/Ex82RKo2Gz9btZuPhs/Tr6McHT07EWKEgLTuPOYu/xUguZ9lrT9eOfPx9+x5+2rCdcYP6MvO6F72HT51l3sdLkbw8+PytebV1XwCupKXx/Nz5lJSW8cUH79E5uP6JD1SVlby2YC75Bfks/+LLBrtOhP8OEbRbqB9+/on8ggI+/fDjm941FZeUcCkmhlnTpja4zSVlHA6tWuHqZPhiKjwqlk7+vhhfl2Wg1ek4H5fIkG51qwEmXM1CLpPh6Vp3P61tLCkuV6FSV2FmUjfgTuwdxNYzsXy44SiB7ZzqzEzzN8m1Fe9P7MVrvx9j6vK/mD0shEGBbW/7jlGj1XEuJZv9Uansj0qluEJN29ZWvDSyM2NDvbA0VXA+OZMlW45zKDIFuVzGmC5+PDE0FGc7K9JyC/lq6xF2no7CRKHg2TF9mTqkKwojI5RXMnjn500kpGUzfWQfnrl/CEZyOTHJqbyydAUarY7l856lnUv1Mfpty26++n0Dg3t0Ye6T02p/pm37DvHR19/j7+PFsrfn1wnYkbGxvPLm2wB8s3gR/r4+Bj8j1GSbLPqQ6JgYFr33AYH+N8/jF+4uEbRboOSUZP7ctJHxY8YS4F//4/D1ElMuAxDgV/9ErwBJl6/i69nOIAgWFJeQfDWD+27IJom7nEZpuYqugXX3mZSeQ1un1gaBub1TdV/05ax8JPe6edkKIznvPzKER7/cxJtrDvDlzFEG03YB9JPasGz6AJbsOs/cdccJaefA7GEhdHC3r3f76+n1eq7mlbD3fDLhyVkci0unqFyNuYmCvn5ujOnsSQ9vF1RVGnadi2dDWDQJmfnYmJsyZUBHJvUOwsnWkkvJ6SzdeJBDEfEojORM6NeJ6UO742hrRXFZBT/uOMz6A6exs7Lgs9kP069jdS3trUdO8cmvG7C3tear12fh1dalev7M1X+yetsehvXuxlvPPY6RXI5er2fF2j9ZsXYD3TsF89EbL2FlcS1gHwk7ycKPPsahdSs+f/9d2jWSNfTVt8vZf/AAzz/9LAP79W9wO+G/RwTtFuirb5djYWHOU0/MvKXtky9XB21vj/preGg0GlKuptE1xHBAyfmYOAA6B9QNzmeiq5d38a/bZZKYno2Xm+HdupdLdRGi+PRcg6AN4O3Smtfv78t7fxxm0cZjzH2wb72BuLu3C6ueGcG280l8t/8Ss37cj6mxEZ6ONrjZWeJgbY6JwgiFkRxVlYbckgpyiitIKyglt6Q639vWwoRePq4MDnKnp48LpgojLl7O4sMNR9gXkUS5ugo/N3vmP9SfkZ190Op07D0Xy8bjF4lNzcLGwoypQ7oyeUAojrZWlKkq+XnnEVbvOUFJhYpxfUJ57sGh2FlZUFxWzmerNrH7RDjdg/x475mp2FlbUa5S8cG3v7Av7CwTRgzilUf/g1wup1Kt5sOvv2f3oWOMHjyA+c/Nqs2j1uv1rNu8hS++X4G/jw+fvfc2re0arrPyy+rf+H39Wibc/yCPTDYchCM0DRG0W5jYOCXHT4bx1BOzaGV3a7NjZ2Rlo1AocHKov3pb4pVU1FVV+Ht7Gaw7eSEKS3NzAr096iw/diEav3Zt6mQ4VFSqSc3OY3g3w77V9s6tsDY3JSIpjTE96h9tOKarH1fzivn5wHlKKipZOGFA7cw111MYyXmgqw/Dg9tzMPoq8ZmFJGUXkZBVxJmkLNRaHRqtDmMjOY42FjhZm9Pd24Xukht+DjZ4Odoil8tIyS5k1aEIdp1PIDW3CHMTBUM7ejG+RwAd3B2JTc1mycYD7AmPpbyyCm9XB16fOITR3YMwNzUmM6+QZX/uYfPRcEorKunb0Y+nxw/Gz736Lnrn8bN8tW4bhSVlzLx/OI+NG4bCyIik1DTmLfmWKxlZPPfIg0wbNxKZTEZOXj5vfPQZUfGJPDVlEo9NfKD2yUej0fDZN9+yccdOBvTuxTtvvIZ5I/Wuf1uzmuU/fM/wocN46fk54sXjPUQE7RZm1ZrfsbK0YuIDDU8rdaO0jAxcnJwaHOIeqYwHoINf3X5RvV7PiQuX6N4xoM6oucKSUi7Fp/DouKF1tk9Kz0avB193w9Q9I7mcrn7tOBaVVG+/NlSPanxmZDdsLEz5aucpIq9k81CvQMZ2k+rt57Y0NWZM5/rratTHtpUFh88l8eP+RA5eSiYhMx+ZDDp7uvLY4M4MDvakSqNh99kYFq3ZTUJ6LmYmCoaF+nN/r2A61AwMOqtMZuPhsxw6X509Myg0kCnDehHkWd1NERGXzJfrtnEpIYVAT3c+e2kmAZ7u6PV6Nu8/wtJf1mFhZsaXC1+ma4fq7q3zUTEs/GQZZRXlLJ73CgN6XhtUU1BYxMKPFnH2QgTTJ0/kmUdnNFquYM0f6/j6u28ZPmQob81bYFCqQGhaImi3IKrKSo6FnWD0yPtueWZ1gOi4+AZfVAGcOn8JF0cH3JzrjgSMSkgmJ7+Q/l1C6iw/ci4SnV7PgNC6c0imZOYC4OVa/yi7yQNCORgRzzfbjvHyQw0XKJrSvyMd2zvzze4zLK/54+tqT5C7I0HtnGjvaEdrK3NaW5tjaWpc5y5Sr9dTodZQUlFJVlEZKdkFpGQVEp+Rx8XLWVSoNchkENzOmVfG9WZwsCetrMw5FZvC+7/v5silRNQaLQHtnJk7eSjDQ/2xMjeloKSM1XtPsOlIOKnZ+dhYmPHw0F5MGtQdF3s79Ho94TEJrNy2j9NRcTjY2bDgicmM6dsNuVzO1cxsFv+4mlMXo+nWIYC3Zz9ePZ+mVscvGzbzw5o/aOPizBdvz8PH49ogoqhYJfPe/5DCoiLefPVlRg8bWt8hq/3Zf/xlJStW/sSg/gN4UwTse5II2i3I0WNHUalUDB4w8JY/k5WTS0ZWFv95oP5pptRVVZyOuMioQf0NHqH3nwxHYWREv651M0T2n4mgjaM9Uvs2dZanZucjl8lwc6i/nzXUpy0T+3di7eFzBHu6Miy04Zeowe2dWf7UGC7nFHI4KoUzCensv5TE5tOxdbYzkstQGMlRyOXIZDIq1FVodXXKwmOiMKK9ox2T+gcT6OZAqJcrNuamRF3O5Ld9p9lzLpb8knJsLc0Y3zuY8T2D8WvrhFan43R0IpuOhnM0Ig6tTkeItztPjB7A4C6BmJkYo9XpOBx+id92HuRSQgqtba15btJoJg7ti7mpKZXqKlZv28nKTTsxUhjx6mMP89DwgcjlcrLz8nn38284czGSEf378MYzM7G0qM5B1+v1/LltO198/wMOre35fsmnjX7x6nQ6li3/mrV/rGf0yPuY9+rroqbIPUr8VlqQcxcuYG1lReeQTjffuMbBY8cA6N65c73rT52/SIWqkr7dQuss1+v1HDwVTo+QQKyvSzVTVaoJj0lg4tC+BkG+XFWJualxndTAGz03th+RKRksWLmDw5cSeWxYD7zdGp4ppb2jHdMHdmL6wE7odHpS84rIKCglv6ScvJIKSioq0eh0aHV6tDodFibGWJubYm1ugr21BR5Odri1tsZILsfGzpwDp5Ws2neGfeeVpOUVYaIwonegJ6O7B9E70BNjhRHpuQV8v/Ug209cIDO/iFbWFjw8tCeje3fC2636aaS0QsXaPWGs33OUtJw8XB1a8fr0hxjdrxtmJiZodTp2Hgnjhz+2kp6dy5CeXXhpxn9wbF19V/7X4WN8+v3PqKs0LJj9JGOHDqo9nkXFxbz32eccPXmS3t278fZrr2Jr03B9Zo1Gw/sff8TuvXuY+OBDvDR7zk2rPQpNRwTtFiQ+MQEfb59/dEHu3LcfyccHrwYyR/YdD8PGypLuIXW7OiLjk8jIyePJiePqLD+vTKRKo6VHB8O7ZEszU8or1eh0ugbbaGFqwooXH+bnPSf5Ze8Z9oTHEuzhyvAu/gS1d6W9UyusLep/wSaXy2jvaEd7x4YzJv6m1+tJzy9GmZrF9pOXiLmSxYWkq6jUmur+dV93nhjZk4EdfbEyN0WlrmJ/eBTbjp/nrDIZgO4B3jw/YRgDO/nXfhFdycxm/d5j7Dh2hnJVJR19PXlu8hgGhHZAYWSEXq/n0OlzfLtuM8lXM5A82rFswUu1IxzzCgtZvPxHDp08QwfJl7deeIZ2ba7VbTl7IYK3P/mUgsIiXnzqSSbfP67R33dZeTkL33mLsFMneeqJWTw6dZp46XiPE0G7hdDr9SRfTuG+YSNu+TMx8fEoExJ55dmn611fVaXh6OlwBvXqYfAofeRsBEZGRvTvVvcOPTalenKjED8Pg/252tuh18OFhCuE1rP+b8YKI54c1YdJ/Tuz43Q0m09c5LMNB2vX29tY4tbaBhsLM6wtzLA2N0VhVJ3GZ2QkRwbodHq0eh1arR6VugqVuopydRX5xWXkFpeRW1RGlVYLVHeheDjbM3lQKB3buRHq646lmQl6vZ6Yy+nsPBnBrpMXKSlX4eZgx6yxAxndqxOu9tVfDnq9nrPR8az96wjHIqJRGMkZ0r0Tk4b2Jci7+stQo9Xy1/FT/Lp5NwlXrtLezYUPX3yKQT1CkdfkXu88eITPf/oNlaqS2TOm8Mj40RjVzC1ZqVbz7cpfWbNxE+5t3Pj087ca7Q4BuHI1lbkLF3D5yhXmvvoa948Z1+j2wr1BBO0WorCokLKyspuWX73exu07MDM15b4hg+tdf/ZSJGXlFQzq1c1gXXhULEE+nlhZ1K3zkVdUgrWFOeb1lP0c3q0D32zaz4/bD9PpxXY3fSKws7JgyuCuPDKoCxn5xSSk53A5u4CUrHwy84vJKy4jOSuf0opKNFotmppUPpmsOtPESC7HSC7DzMQYMxNjzE2MaW1tQSfvtjjaWuJmb4t/W2e83RwwNVbg6GhNZlYR0SlpHAiP5sC5aDLyijBWGDEoNID7+3Yh1K99bbsr1VXsPhHO+r1HSbiagZ21JY+PG8ZDQ/pgb1vdXaFSq9l5+ASrtu0hLSsHjzauvPXsYwzv2wNFzUvAhJQrLP7uRyKilQRLviyc8zQeba+9D0hITuatjz8hITmFh8aM5vlZTzSazgdw7MRx3v7gfYyMjPj8k0/p1qVro9sL9w4RtFuIlJoBMu7uhlNL1aeyspI9Bw8zYtBArBvINDkdcQlTE2O63dA1otFqiU26zJSxhnf15apKTIzrP+3MTE14dFQ/lqzbzVOf/MzcaWNr+4AbI5PJcLO3xc3e9hZ+sn8uu6CYiMQrhMelcDA8moKSchRGcnoEeDNr7ED6h/hjY3ntyymvsJgNB06w8cAJCkpK8XF3ZcETkxnes3NtlcOSsnI27DnE2l37KCgqIdDbgxemTaRfl5DaoF9SWsbPf2xi7bZdWFtasOD5pxgzeEDtep1Ox5qNm1m+ciXWVtYsee8d+nQ3/AK9nlqt5psfvmPtH+vx8/Vl0bsf4Obq2uhnhHuLCNotRGR0FAABknRL24edPY+qspJB9Ux28LcraRm4u7lialJ3AEtZhQqtTodDK8Mg6uvuxo5jZ8gpKMKxnvWTB/fA0syUL/7cw9R3v2XaiD78Z0gPWtvceori7dBoteQXl5GWW0BaTj5XcwpIuJpFdEoauUXV80baWVnQI9CbPsG+9O7gWydQ6/V6LsansOlgGHtPnUer09EnJICHRwygS4BPbT9xbkEha3fuY8Pew5RXqOjVqQPTx4+kc4Bf7Tbqqio27NzDT39soqS0jDFDBvD8jCl1XiZmZmfz7qdLCI+4SP9ePZn/4gu0smv8Sys+MYF3PnyfhMREJjzwILOffrbeiQ6Ee5sI2i1EZFQUbd3a3PIoyBOnwzExNiY0pOFC9xnZOQa52QDlFdXDvc1MDEcjBvt6AHD0QhQPDuptsF4mkzG2T2f6dvTjiz/3sHLXUVbuOoqHiwOdfNvh7mSPq70dra0tsbW2QCGXI5fLkMtkaHQ6qqq0qDUa1FUaKirVlFeqqahUU1ZRSamqkrKKSkrKVZSUV1BcrqKwtJz8olIKSsvQX5fpJ5fJaOvUmq7+ngR5tCHQsw39u0oU5JfXaW9JWQW7w8LZeOAESWmZWJiZ8uDgXkwc2q+2oBNAenYuq7b+xdaDx9BqtQzp1ZXp40fid11OtUarZc+R46xY+ydpmdn06NSR2TMewc/Lo87/+deBgyz+6ht0Oh0LXnqBsSOGN/rysKqqil9Wr2Llql+xsbbh0w8X0bd3w1/Gwr1NBO0WQKfTceHiRfr2NgySDVGr1ZiZmhrcRV/PwswMlcpwWi7HVraYGCu4nJFpsC7Q051gHw++37CbwV07Ymdd/x10K2tL3n7sAaYM68WJS/FciL/C0Yg48or/3WzppsYKrMzNsLE0w9rCHNfWtnTwbIODrTX2tla42dvRxrE1rva2BqmHf/cxl6sqOXo+ir2nzhN2MRaNVkuApzvzH5vEsJ6da+e1BLiSkcUvm3ex6+hJZMDogb2ZNm4k7i7Xvuw0Wi1/HT7GT+s3cTUjE1/P9nzx1jx6htYdlFRSWsriL79mz6HDdAwM4O3XX6XNTbo2LkVFsujTT0hMTmL40GG8PHsOdo3UGxHufSJotwCXr1ymqLiIziEhN9+4hrGxMZVVVWi12gZHxdm3bkXylasGyxUKBT7t2hIZn2SwTi6X8/qMh3ji3S94eekKPnnhidqXcvXxbeuCb1sXZtxX3QVRUFJGfnEZ+SVlFJdVoNXp0NXkWSuM5BgrjDBRKDAxVmBuaoKFqQnmpsZYmpthaWbSaA54Q/R6PcnpWWw5GsbeExe4EJdElUaLYytbJg3ry/CeoQR41n1XkHDlKr9s3sW+E2cwVih4aPhApo4djrP9tVrUqko1Ow4cYtWm7aRnZePn6cHi+a/Sv3sXgzvnE2fO8OHSZeQXFPDUjGlMnzyp9kukPiUlJSxf8T2btm7B0cFR3F3/DxFBuwVISKoOnpLfrfVnA4SGdODHVes4fvoM/Xv1rHebIF9vDoWdJiM7x6COdv+unfh23WaSUtPwcq878tGvXRvee3oqb363mhlvLWHxnMcI9Gp8/kao7jppbWN11/u3i8vKibucRlTSFS7Fp3AxIYWi0jIAvNq4MHFoP/p3DiLEz9MgwyUyPomVm3dy9GwEFmamPDJmOI+MGV6nMFZJaRkbd+9j7bad5BcW0UHy5aUnptOvnmBdVl7OF9+vYMuu3Xi1b88n77xJgG/DJXL1ej37Dh5g6ZfLKCwqZPJDE5j1+EwsLQxrrwjNkwjaLcCV1CvIZDLc295a5gjAsAF9cXZ0ZM3GTfTr2aPePtPBvXvw9a9r2H/8JFMfGFtn3YPDBrBy806+W7+VRS8/bfD5gV07ssLRnteX/cxTH37FjNFDeGBQrzrB7W7T6/Vk5xeivJxG3JU04mr+zsgtqN3Gw9WJ/qFBdPTxYGT/UExkht1FWp2Ow2fOs2b7Xi7GJWJjZcmsieOYOHJw7cwyAFm5eazbtotNf+2nvKKCHp06MmPCeEI7BBocH71ez8Fjx/n8ux/Iyctj+qSJzJo2FZN6CmXV7j87i8VLl3A87AT+fhJLPl6M/z/4ohaaBxG0WwCtVotMJmv0cfpGCoWCqRMf4rNvvmXX/gOMGjrEYJu2ri4ES75s3L2X/4wbVWf/ttZWPPbAKJav3cy2g8cYN7ifwef92rdh5dsv8sFP6/lh81/8tG0vg7p0ZGz/7nTw8cDKvPFc41tVpdGQkZtPalYuadl5JKdlkZiWQdLVTErKq6cwk8lktHVyIMi7PQ8O7o1fu7YEeLatE3RvnG4sv6iYnUfC2LDnEOnZubRxduSlGZMZN7gvFtflSSdducqqTVv568hx9Do9g/v0ZNqDY5G86q8wmJqWzmffLCfsbDg+np58MH8uwYENzxij0+nYuGUz33z/LTq9nuefeY7JD00QtUP+R4nfagvg6uKKTqcjOycbN1e3m3+gxkNjRrPv8FGWLP+Orp1C6q2nPfWBsbyxaAkHT5xiWL+6Lzqnjb+Ps5FKPv1pDX4e7fD3MhwKb2dtxScvPM6VzBw2HTzBtiOn2Xf6AjKZjPYujvh7uuPUyhZrS3OszM0xksurRwiiR6fTUamuorKqClVlFeWqSsoqVJRVqCguKyevqIT84hKKSsvRX5caYm1hjndbV4b37IxXW1f82rnh4+5W5wViQ9RVVZy+GM22g8c5eu4iWq2WEH8f5kydSP9unepMvHAxRsmvG7Zy9Ew4piYmPDhiGA+PH1Vvxg1Abl4+v6xfz+Ydu1AYK3jp6SeZMG5so1+2mVlZvP/xR5w9F06Pbt144+VX/9HvWGh+ZNefzHdaTk7J3dv5HdLQZK3/S+ITEpg+63FGjRh5yzNp/31cUtPSmfLMc3QJ6ciSd982+KxWq+OROa8CMlYvW2wQYPIKi3l0/vuoVJUsmTuHYL+6M9XcSFWp5rwykejkVGKSUom9fJWC4lI0NU8LjZ2v5qYmWJmbYWluhrWlBfa21rS2scbe1ho3J3vaOtnT1tmBVtZW/6i+RlFpGWcuRRMWEcmBk+cor1BhZ23FqAG9GTeoL55tr2Vw6PV6ws5d4Jc/t3AhOhZba2smjRnBhFHDsbOpv+snr6CAVX9sYMO27Wg0GkYPH8qT06fhaG/fYJv0ej3bd+1k6VfL0Ov0vPDcbMaPGdskdUNawjX0T/3bY+LoaN3gL1IE7RZywv3w84/8vFNQtwAAFU9JREFU+MtK5r7yGvePvXmNieuPy+8bNvLF9yv44oP36Nm1i8G2B8NOM3fREhbMfpJxwwyHvKdn5zD7/aVk5uYzbdwIpo0bUWfOwpvR6/VUqqsorVChrqoCZMhk1bnUZqYmmBobY2KsuGOV6YpKSrkYl8j5mDjORsYSl5KKXq/H3s6GvqEhDOzemW7BAXUyUTRaLfuPhbFq03biklNwdrBnyv1jGDdsUINDyiNjY/ljyzb2HTmKTqdj5OBBPDHlEdq6NZ7GV1BYwEefLObI8WN0DunE/82d16R31y3lGvonRNC+i1rKCafVanl57mucPnuWx6fP4PHpjzZa4P7641JVVcWkmU9hY23Fyi+/qPel2aw33uRqZhZrvvyUVraGd5SFxSUsW/UHOw6HYW5qyvC+3enXJYTOAb7/KIDfaXq9ntSMLCKUiUQo47moTORyenV+ubFCQbCfN107+NM1yJ9BvUPIzy+r8/kKlYpt+w7x+5btZGTn4tHWjWkPjmNE/74Y1zNcv7yign2Hj7B55y6ilHFYWJgzZvgwJo4d0+gEu387cTKM9z9eRElpCc/MepL/TJjU5GVUW8o19E+IoH0XtaQTrqKigk8+X8LOv3bTNbQL7yx8E/vWrevd9sbjsmXXbj78fBlffPg+PbuEGmyfkHKFGa/MY0CPbnzw2gsNPqbHJF3mz78OsvfEGSrVauQyGQHeHgT5euHV1g1vdzfat3HFxtLirjzq63Q6ElPTOR+t5FxMHBdi4ykoqv45bawsCZF8CPbzJtjPi0BvjzrDvK8/JlfSM9iwcw/bDxymtKycjgES0x4YS99uofUG0Zj4eDbt2MXeQ4cpr6jAo507E8aMYdSwIbeUjldeXs6X337Dpq1b8Pb04u2F/4evd+NV/P5bWtI1dKtE0L6LWuIJt33XDj5ZugQ7OzuWfbqU9u0Mc6RvPC5qdRUPPvY47m5uLP/k43r3u/LPzSz/bS3D+/fm1Scfx7aB0Y5QXQEvMj6Js1GxnI2MJT4llYrKa6MrLc3NcXW0x9XJHlcHe1wc7HFxtMfFoTUuDq1pZWN90zvMKo2G9OxcUtIyiE5MISo+mejEFMoqqjNGXB3t6RzgR4i/DyGSL+3dnBvdp42NKZt2HWbbvoOEnasuPTukTw8mjR5JsL+fwfaqykr2HznKhm3biVLGYWpqytD+/Rh/3wg6Bhqm+TXkwsWLvLfoA9IzMnh44mSeemImpvdQzZCWeA3djAjad1FLPeGU8XG8+NormJqa8uuKn7Gxrjsqsb7j8nff9s/LPidQMgxSOp2OlX9uZsXaDbS2tWHh808bDMVuiE6nIzM3n6TUNFIzs0nPziU9O5eMnDwycvNq65n8zVihwKGVLTaWllhbWWBlbo5Wr0OlUlNRWUlBcQkZ2bnoas5vIyMjfNq1IcjHk2BfLzoHSrg6Nvyi728ajYYL0bEcOHGKvcdOUFxShqN9a8YPG8QDI4bi0Nqwlkt6ZiYbtu9g6+49FJeU4NHOnYfGjOa+IYMbrJhYn4qKClas/Inf16/D1cWFN+ctoFPHWx/V+t/SUq+hxoigfRe15BMuOjaGWc89w4ihw3hz3oI66+o7LmXl5YybOoOunUL4+M2FDe43NjGZt5d+TXLqVTpIvnTr2IFuIR3oIPk2WsukIXq9ntLyCjJy8sjKyyczN5/svHyy8wooKS+npKyC0rJyjIzkmJmaYm5qgo2VFe6uTrRzdaadqzM+7dvWW8CqPnmFhZy7FM3xs+c5fvYcxaVlmJoYM2JgH4b26U3X4A61kw9c38bwiIus3bSZY6dOI5fJ6N+7FxPGjqFLSMd/3NVz8vQpPl7yGRmZGYwfM5Y5z86+Z0c1tuRrqCEiaN9FLf2E+/zrL/lj4wa2rP8TB/tredgNHZcVq1bzw2+r+e6zT+jUIajB/Vaq1azZupOjp8OJiU9Eq9Mhl8twc3bGo60bHm3b0M7NFXc3F9q5uWLfyq5J0tX0ej3pWdlcio3nYmwc5yKjSU6trqdiY21Fv26hDOjRje6dgmnn7mhwTKqqqth76AhrNm0iLjEJO1sbHhh1Hw+MHo2zY8NzVzYkNy+Xr75dzu69e2jfrj1zX3n1H83p2RRa+jVUHxG076KWfsKlXr3KxKkPM+uxx3lixmO1yxs6LhUqFQ8/+TTGxsasWPoZtg3kHl+vtKycc5HRxCQkcTktnctX07mSnlGTvlfN2tIS7/buBPn5EBLoT2hQANbXjUa8U/ILi4hJSKr5k0hUXCIFRUVAddXCjgESXYID6RIchOTtWSfv/PpjkpuXz4btO9i0cxcFhYV4tmvHww/ez4jBg26rRnV5eTmr161h9bq1aDQapj8yhRlTpt1TfdcNaenXUH1E0L6LxAkHz744h8LCQn5f+WvtssaOS3jERV5c8H+4ubqw7MMPbuuOUqvVkZWbS2pGJlfS0km6cpW45MsoE5Op0miQy2UE+HjTrWMHQgIlgvx8G32xeaOqKg1X0jNITr1K4uVU4pJTUCalkJOXD1QPW2/fxo0gP286SH4E+/vi5e5u0O1xvdatLdi55yg79u7jwLHjaLVa+nTvxsRxY+nRJfS2nhTUajU7/9rNj7/8TE5uLkMGDeaZmU/Stk2bm3/4HiGuIUMiaN9F4oSDNX+s44uvv2LD7+to41Y9SONmx+XcxUu88tbb2FhZ8eGC+QT535nCROqqKqLiEjgTEcmZiEtExSWg1ekAaN/GDa92bXFo3YpWtja1/eOqSjWVlZXkFhSSmZNLVm4umdm5tZ+Ty2W0b9MGycsDyduz9u9byQ/X6/XExMWz9/AR9h0+THZuHtZWVtw3dDCTxo3Dvc3tDWqpqKhg49YtrFm/lty8PAIDAnjxuefp2CH45h++x4hryJAI2neROOEgPSOdBx+ezNMzZ/Ho1OnArR2X2PgEXvq/t8gvKCDIX2LCmDEMGdDvtl42NqS8QkV0fCKRyjguKeO5mpFJbkFhzYtHI7Q1M6YrFEbY29nh7OiAq6MDbs5OeLq3wdO9Le3auGFmeuttUqlURMbGcuzUaQ4eO05mdg5GRkYM7teLwX3707dHj0ar7TUmPSODTVu3sHXHdoqKi+gaGsr0R6bRrYthWdbmQlxDhkTQvovECVft2RfnkJ2dzfpVvyOXy2/5uJSWlbFz3342bNtBSmoqFhbmBPr5Vf+R/Ajyl+otNPVvqauqqKhQoVAoMDU1+UcVDG+UlZNLVGwsMXHxXIiMJDouHo1Gg7Gxgh6hoQzq24d+PXvi4+12W+eKRqPh5OlTbNmxneNhJwDo16cvUyb/p1neWd9IXEOGRNC+i8QJV+2vfXt56/13+ejd9xnUf8A/Pi5/p7wdOHqM6Lg44pOS0Wg0ADi0bk2Anx8dAiRCgoIIlPzu6N34P2ljTl4ecQmJxCYkEpeYSExcPNm5uUB1OdpAP186BXegc3AHOgYGYWV5rQvlnx6TzKwstu3cwbadO8jOyaZVq1aMHz2WB8aNw9nJ+Y7/fE1FXEOG7smgLUnSAGARoK5Z9KhSqUy+fhsRtJsPjUbDtJmPodFoWLPyN1xdW/2r46JWV6FMTKy+g42PJ0YZz+Wr1al0xsYKAvz86NapE91DOxMk+WFsfHvdDQ0pr6ggMTmFpMuXSUy5TEJyMvFJyRSXVP9MMpmMdm3aIPl40yHAnyB/CT8v70a7PW7lXFGpVBw6eoQdu3dx9lw4AD26def+sePo26v3/2SNa3ENGbrngrYkSXIgDeivVCrjJUmaA3RWKpWPXb+dCNrNy/GwE7wy7w2mPTyFtxe+dsePS1FxMRFR0URERXH+4iVi4hPQ6XSYGBsT4OdHoORLgK8vvl5eODs53nQwiV6vJ7+wkIysLNIzs0i5kkpiSgqJKSlcTc+oLeNqZmqKt0d7fLy88PX0xMfLEz9vr388WKWxcyU+IYEt27exe+8eSstKcXN1ZdSI+xg1YiRuN5l8t7kT15Chuxm0b+trX6lU6iRJ8lcqlUU1i7KBO99xKfxX9e7Zi/vHjuO3NauR/DwZOmjEHd2/rY0N/Xv1rJ1zsrikhPCIi0RERXEpJpaN23dSqVbXbm9pYYGjvT2mpqYoFEYYKxRotFpKy8ooKyunuKSkzvZyuRx3Nzd8PD0ZOXgwft5eeHu0x9W58Zoit6uoqIh9hw6wY9cuomNjMDE2YeCAAYwfPZbOISFNXn1P+N90289qfwdsSZJMgZeo7ioRmjGZTMarL7xEdk42b73/EXqdEcOGDL1r/5+NtTWD+vZhUN/qWcI1Gg3JV1JJSkkhOy+P7NxccnLzqFSr0Wg0aDRaLIyNcXJwwMrSAmsra1ydnHB1dsLF2Ym2bm63NbDln1CpVJw8c5pdf+3m+MkwNBoN3p5evDR7DiOHj7ilwUaC8G/ctHtEkqTHgBduWJyuVCpHSZJkA2wGjiiVyrdv/KxGo9UrFLf/Vl9oGmVl5TzxzGzOnjvPwrmv8ejUR5q6SU0qNy+f42Fh7Nl3kMPHjlFRocLB3p7xY0Zx/9jRBPhLzTZdT7hn3ZUXkZbAfuA3pVL5dX3biD7t5sva2phnX3iNw8eOMu3hKTwz68kW87ifnZNDZHQU5y6cJ/z8OZJTUgBwdHCgX5++DOw3gNBOnf4nXyreDnENGbrn+rRrfA2saihgC82bmZkZH77zHp9+vpTf1qwmOyebhW/Mu+NZHk1Jr9eTnZNNXEIC8QkJxCXEEx0TQ3ZONlB9DDp1DOG+4SMJ7dSJAf26k5dXdpO9CsLddVtBW5IkZ2Aa4ClJ0oSaxTlKpXLiHWuZ0OSMjIx4/eVXcHFxZvkP35OTm8vH732A9Q21t5uL4pISLlyM4FJkJMr4OJRxcRQVF9Wub9umLZ06diQoMIgOgYH4evtgcl0+eUt50hDubbebPZIFiM7qFkAmkzFjyjScHJ34YPEinnz+WZYs+gRXF5embtpNqVQqzkdEcDr8DOHnzxGfkIBer0ehUODt5cWAfv3w8/XDz8cHby/ve7ZetSBcT3TKCbfkvuEjcHJ05I2FC5j57FPMe/V1+vTqfU+9gNPr9aRcTuHEyZOEnT5FxKWLVFVVYWJsQnCHDsx89DG6dA4lQPJvFiVPBaE+Yhi7eIlSr4aOS1JyMnPfXMCV1FS8Pb14eNIkBg0Y1OhdqkajobS0FI1Wg6mJKaamphgbG9+RgF9UXEz4+XOcCT9L2KlTZGZVz6Tu5eFJj+7d6dmtOyEdQ+5IKqA4V+onjouhe25E5K0SQbv5auy4VFVVsWf/Pn5fv5bEpCQArCytcHJ0xNbWFpVKRXl5OeUV5ZSWllGhqjDYh7GxMZ4eHki+fvj5+BLg74+fj2+dPuQb6fV6MrOyiIyKJDI6mohLF1HGx6HX67EwN6draBd69+xFrx497kptD3Gu1E8cF0MiaN9F4oSr360cF71eT/j5c8QoY8nKziYnJ4fikmLMzMyxMDfHwsICKysrrK2ssLKyQmGkoFJdSWVlJcXFJSQkJRIXH0dhzcwxJsYmBPj74+LsTCs7O+Ty6tcm2TnZpKWnk5aeVls7xNTUlADJn66hXejWpQtBAYF3PQVPnCv1E8fF0L2a8ie0cDKZjK6hXega2uW29/F32l1UTAyRUVFciorkYmQkxSXFaLVa9Dodjg6OtGnjhr80GC8PT4I7dMDHy1vkSQstkjjrhSYlk8lwdnLG2cmZwQMGNnVzBOGeJxJPBUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhERtAVBEJoREbQFQRCaERG0BUEQmhHFv92BJEldgJOAr1KpTPnXLRIEQRAa9K/utCVJMgW+AJR3pjmCIAhCY/5t98i7wI9A7h1oiyAIgnATMr1ef1sflCSpFzBfqVSOlSTpEPDojd0jGo1Wr1AY/etGCoIgtDCyhlbctE9bkqTHgBduWJwPWAIPNvbZgoLyW2lck3J0tCYnp6Spm3HPEcfFkDgm9RPHxdC/PSaOjtYNrrtp0FYqlT8DP1+/TJKkYcBXwAZJkgACgU2SJE1SKpXxt91SQRAEoVG3lT2iVCr3AtLf/26oe0QQBEG4s0SetiAIQjPyr/O0AZRK5cA7sR9BEAShceJOWxAEoRkRQVsQBKEZEUFbEAShGRFBWxAEoRkRQVsQBKEZEUFbEAShGRFBWxAEoRm57YJRgiAIwn+fuNMWBEFoRkTQFgRBaEZE0BYEQWhG7kjtkf8VYr7LayRJGgAsAtQ1ix5VKpXJTdikJiVJ0v8Bo6kuTr9DqVS+28RNanKSJH0ADKX65u+YUql8qYmbdE+RJGkp0PlO12YSd9o1xHyX10iSJAfWAtOVSuUAYAPwZtO2qulIktSD6gk/+gP9gLGSJPVu2lY1LUmSRgN9gV5AD6BvzRe9AEiS1B/ocjf2LYL2NWK+yxpKpVIH+F83oUU24NCETWpq9wFblEqlWqlUqoEtwKgmblNT+wsYrVQqdTXnSx4t+xypJUmSJbAYeOVu7F8EbWrnuwysmaVHAJRKZRHUPoG8BPzUtC1qUm5A5nX/zqxZ1mIplUqNUqkshdonEYnqQC7Ap8ASIOdu7LxF9Wn/m/ku/1c1cEzSlUrlKEmSbIDNwC6lUrnpv9+6e5YMEAMcAEmS+gErgYf+DuItWc1UjPZKpXK9JEked+P/aPGDa66b77KgZlEgkAi06Pkuax7x9gO/KZXKr5u6PU2p5iWksVKpfLPm328BcqVS+VbTtqxp1fRhfws8oFQqY5u6PfcCSZJ+ALoClYAp4A1sViqV0+/U/9Hig/aNxHyX1SRJWgmcVSqVXzV1W5qaJEmhVN9Ndq9ZdAp4QqlUnm2yRjUxSZJaAyeAkS39WmlIzZ32yjudPdKiukeEWyNJkjMwDfCUJGlCzeIcpVI5sQmb1WSUSuU5SZJ+A45Q3S3yW0sO2DWeAOyAlZJUO8f3b0ql8sema1LLIO60BUEQmhGRPSIIgtCMiKAtCILQjIigLQiC0IyIoC0IgtCMiKAtCILQjIigLQiC0IyIoC0IgtCMiKAtCILQjPw/zIYQYtTPZPMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "trace = approx.sample(10000)\n",
    "sns.kdeplot(trace['x'][:, 0], trace['x'][:, 1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stein Variational Gradient Descent (SVGD) uses particles to estimate the posterior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:41<00:00, 242.58it/s]\n"
     ]
    }
   ],
   "source": [
    "w = pm.floatX([.2, .8])\n",
    "mu = pm.floatX([-.3, .5])\n",
    "sd = pm.floatX([.1, .1])\n",
    "with pm.Model() as model:\n",
    "    pm.NormalMixture('x', w=w, mu=mu, sigma=sd)\n",
    "    approx = pm.fit(method=pm.SVGD(n_particles=200, jitter=1.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "trace = approx.sample(10000)\n",
    "sns.distplot(trace['x']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information on variational inference, see [these examples](http://pymc-devs.github.io/pymc3/examples.html#variational-inference)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Posterior Predictive Sampling\n",
    "\n",
    "The `sample_posterior_predictive()` function performs prediction on hold-out data and posterior predictive checks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [sd, mu]\n",
      "Sampling 4 chains: 100%|██████████| 4000/4000 [00:00<00:00, 6391.82draws/s]\n"
     ]
    }
   ],
   "source": [
    "data = np.random.randn(100)\n",
    "with pm.Model() as model:\n",
    "    mu = pm.Normal('mu', mu=0, sigma=1)\n",
    "    sd = pm.HalfNormal('sd', sigma=1)\n",
    "    obs = pm.Normal('obs', mu=mu, sigma=sd, observed=data)\n",
    "    \n",
    "    trace = pm.sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [00:00<00:00, 4278.10it/s]\n"
     ]
    }
   ],
   "source": [
    "with model:\n",
    "    post_pred = pm.sample_posterior_predictive(trace, samples=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sample_posterior_predictive()` returns a dict with a key for every observed node:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 100)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "post_pred['obs'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW8AAAD1CAYAAACftnSFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xd81dX9x/HXHUlu9t4BwjxAICyRIQJuxDprW63WumqrYi1aW1tH1dba1lZqFa3bFrUWq5Xyc+JEBJG9OeyRkL13csfvj5tggITcJDf53vF5Ph4+HuR+b773fbzJJ+ee7/meY3K5XAghhPAvZqMDCCGE6D4p3kII4YekeAshhB+S4i2EEH5IircQQvghKd5CCOGHrP31QiUlNQE1JzE+PoKKinqjY/QJaZtnYi+ZC0DV2+965Xy9Ie+Zf/KkbcnJ0aaOHpeedw9ZrRajI/QZaZv/CdR2gbSt0+/1Yg4hgkr9/LuMjiCCmBRvIXqoZdYZRkcQQUyGTYToIcuWzVi2bDY6hghS0vMWooei7rsb8I0LliL4SM9bCCH8kBRvIYTwQ1K8hRDCD0nxFkIIPyQXLNt56qnH2b59G83NzezercnJGQvAt751MXPmXGBwOmGEtzYXdHos9Xu3AlDU7jmX5ab3eSYhQIr3MW655XYACgqOcMstN/Lkk88anEj4sqKciUZHEEFMireHXnjhGQoKjlBYWMC8efO5444nuPLKHzJ58pSjxf6//32X6upq/vznR6isrKC2tpYrrriac8+dc8K5ysvLKC8vY8+e3Vx11TXs3r2LnTt3kJiYxB//+Bgmk4n//Od1PvnkIxwOB4MGZXPnnb8kLMzG88//nXXrvgYgOTmV++//LVarlfPOm8U111zP6tWrKCsr5aGH/sDQocOM+N8VFFK3rQekiAtj+Fzxblvsp72miy6l8fofQX09sd+//ITjjVdcRdMVV2EqKyPmhh+cePzaG2i65Nu9zlZQcIQnn3wWk6nDdWIAeO65p5kyZRoXXHARDQ0NXHvtlUyePIX4+Phjnnfw4AGeeOIZNmxYx/z5t/Laa2+SkZHJd797MXv27KKlpYXlyz9j4cLnMJlM/O1vf2Hp0re55JLLCQuzsXDh85jNZu64Yx6rV6/itNNOp66ujiFDhnHVVT/kxRefZenSt/nZz37e63aLjp36wgIAlj62yOAkIhj5XPH2ZTk5Y05auAE2bFjLzp3beO+9/wPAarVSUJB/QvHOyRmLyWQiJSWVhIREMjOzAEhKSqa2tpbt27eSl3eY2277MQCNjY1YrVasVisWi5lbb70Ri8XKwYMHqKqqPHreiRNPASAtLZ38/MNea7sQwrf4XPE+6d1qEREnPe5KTOzTu92s1pAOH29paTn675CQEO68825Gjhx90nNZLJYO/w3gcrkICQllxoyZ3HHHL485tnnzRt555388//wiwsPDuffeX3R6XldALcIrhGhPpgr2UFRUFMXFRQCsX7/m6OO5ueP55JNlADQ1NfLnP/8Bu93e7fPn5o7jq69WUl/vXuv3rbfeYOvWzVRUlJOWlkF4eDiFhQVs27aV5uZmL7RICOFPuux5K6VCgSeBMYAJ2AzcorV2tHvOjcBNgB3YCMzTWjv7JLGPuPrqq7n33vtYtux9pkyZfvTx66+/iT/84XfcfPMNtLS0cNFFl2K1dv8DzsiRo7nssu9w220/JjQ0lKSkZObOvZAhQ4bx+uuvcPPNNzB48BCuv/4mXnrpuaPDJUKI4GBydfHZWil1EXCO1vq21q8/BxZord9u/ToL+BIYB1QBbwP/1lq/1v48gbaTTnJyNCUlNUbH6BPStm+cbJ534p4dAJQNG3X0MaPmect75p88aVtnO+l02SXUWv8P+B+AUioKiAPy2j3lbOBTrXVl63PeAOYCryFEAGtftIXobx6PeSulXgb2Aq9orde2O5QBFLb7urD1MSECWua6lWSuW2l0DBGkPB6M1Vpf29rzXqqU2q+1/k8nTzUBJwyRxMdHBNxedMnJ0UZH6DPSNrfoqIpOj01+/RkAqmed2aNze5u8Z/6pp23z5ILlRKBOu9Uqpd4GzgDaivdh4Jx235LBscMqAAG3+3Owj8P5q+62raa2sdNjDofzhOf05P/bycbVO3P82Lq8Z/7JwzHvDh/3ZNhkCvCIUqpt0Hw6sK3d8WXALKVUolLKDFxJ6xi5EEKIvuFJ8X4OKAC+VEp9BdQBzyulXldKZWqtC4F7gPdxzzrZBrzVV4GFEEJ4NtvEDtzawaEr2j3nFeAVL+YSQghxEj53e3xPxv884cn824KCI3z/+98+uo63w2EnNTWdO++8m+jo7l9U+OCDdznvvBMX2urM7t2a//u/Jcyf/4uun9zH1qxZzT/+8QJPPvksjz/+F847by4jR3Y8NW7//n00Nzej1EgWLXqZoUOHMX36jH5O3P+Wz3/Q6AgiiPlc8TZaXFz8Met4L1z4OP/4xwvMm/ezbp3H4XDw0kvPd6t4Dx+ufKJwH+/22+886fHlyz8lISERpUbygx9c2z+hfEDVgCFGRxBBTIp3F8aNm8D//ucewt+2bStPPrkAq9VKaKiVefPuZPDgISxe/C8+/PA9bDYbYWE27r//IZ54YgFFRQXMn38rCxYs5OOPl/Hmm//G5XIRFxfP3XffS2xsHOeeO4tvfesinE4nM2eewXPPPc3TT7/AoUMH+fOfH8HpdOJwOPjJT25j3LjxPPzwA4SEhHDo0EF+85vfkZyccjTr5ZdfyDnnzGH79q1UVlZy++13MnHiKcybdxPDhyt279Y8/vjTbNq0gRdfdP+Bslis/PKX95CRkcny5Z/x7LNPkZWVQUrKN59U5s27iR/+8AYmT57Cyy8/z4oVyzGZTMyZMxelRvHmm4uJjIwkLMzGmjVfkZs7ntWrVzFz5hlH1zL/wx9+i1KjOOuscw1d7/zmm2/mk08+O2a986effoL169cQEhJKcnIy99zzIKGhoV3+bAxa9QkAB6ed2cUzhfA+Kd4n4XA4WL78U3JzxwPwu9/dz/33/5ZRo3LYunUtjz32R5544hleeOHv/Otfb5GQkMjq1asoLS3lhht+zLp1a1iwYCFFRYX8858v8txz/yA0NJTFi//FP//5ErfdNp+GhnqmTTuNyZOnsn79N/c+/fWvj3LJJZdz5plns3fvHu6++07eeGMJ4F4etrNdfmJiYnn88adZu/ZrnnxyAS+++CoA4eHhPPnkszQ2NvLoo7/nmWdeIiYmli+++IyFC//Kww8/yoIFf2LBgoVMnpzLPffcf8K5N23awMqVK3jmmZdwuVzcc89dnHvuXKZMmUZu7njOPXcOa9Z8BcC5557P+++/w7nnzsFut7Nq1QpuueWnhq93PmLECC655Iqj651ff/1NvPXWG7z//qdYLBY+/ngZ5eXlpKWldfnzkfvGS+6sUryFAaR4H6eysoJ5824C3Euz5uaO53vfu4qamhoqKsoZNSoHgFNPPZX58+cD7j0u77zzNmbPPoszzjibgQMHUVBw5Og5t27dQllZKXfcMQ9wLyGbnp5x9DXGjh1/Qo7t27fy4IOPADB06DDq62uprHSv2z1mTG6n+adMmQrA2LHjOHBg/9HHx451f8++fXsoKyvj17++CwCn04nJZKKqqpKmpiayswcDMHHiZPbs2X3Mubdt28q4cROOLjv7xz8u6DTHtGmn8dhjf6ShoYGNG9cxevQYYmJiDV/vfOrUqVRXNx9d7zwmJoYpU6Yyb95NzJx5BmeddQ4pKamdtksIXyHF+zjHj3m3aWpqOuZr94Je7qnvt912B4WFBaxa9SW//vXPufXWnx0tggChoSGMHp3Dn/701w5fs+NVB49di8blgrZ9IEJCOl5XHMDpbLu59Zt87tcIaf3eUFJTU09oY2VlJWbzN893Oh0cz2Qy4XR6tlhkSEgI06adxsqVK1i1asXRsX9fXO/8d7/7EwcPHmDlyhXMm3cTDz/8J4YPVx61UwijyHreHoqKiiIxMYlt27YCsGrVKnJyxlBdXc0LLzxDSkoql156OZde+h127NiGyWQ+uo73qFE5bN++jbKyUgA++eQjvvjis5O+Xk7OWL7+ehUAu3btJCYmltjYuC5ztq0tvnnzxg73rxw4cCBVVVXs27cHgI0b17NkyVvExsZiNls4fPgQAGvXfn3C944dm8u6dWuw2+3Y7XZuu+3HlJaWYjKZOlyz/Jxz5rB8+Sds3ryR6dNPB3xvvfP8/Dz+/e9XGTQomyuvvJpZs8484RNHT7U4nFTUN2N3BtSCmsJH+FzP26glNT1x770P8sQTCzCbzdhsodxxxy+JiYmhvr6eG2+8hujoGKxWK7/61X3ExcWTkJDI9ddfzcKFz3H77Xfyi1/MP3pR8957Hzjpa82ffxePPvoIb7/9Jna7nfvue8ijjMXFxdx11+0UFxdz552/POF4WJiN++57iEce+S1hYWEA/OIXv8ZkMvHTn97Br371cwYPHnTMBcs2Y8bkMnv2mdxyy40AnH32eSQlJTFp0mQWLnyc45cXHj9+Ir///YNMnjz16AVAX1vvPCUllV27ND/60TVEREQSHR3Nddf9qNt5GlocHCyv55FltWwtqKaktpmKBvcOSyYgLjyE1OgwzhyRxIU5qSRFhXX7NYRor8v1vL1F1vPue5dffiF//etTZGUN6NV5fLFt3uLN9bwjiwsorG7kw9owdpfU4QIiQy3kZsSQHmMjKSqU6DArVQ0tlNe3sLe0jk1HqrGY4PShicyfPZSMWJusbdKFYG9bj9fzFkKcKL+ygc8OOThUYcdmdTIlO55hSZHcOiMbq6Xz0ciD5fUs2VLIW5sLuO61DSy4dEw/phaBRIp3APnPf5YaHSHgOZ0uvtxfzpf7y/n27hV8PymSlksvJ9TqLtgnK9wAgxIi+OmsIXxrTCo/e2srP/73Jr41JpXhyVH9EV8EELlgKYSHKhtaeGVtHiv2lZOTFs3Pdn3MRauWHi3c3TEkMZIXvz+BwYkRvLmxgN0ltX2QWAQyKd5CeKC0tpl/fn2Y0rpmLhqTxoVj0jCbOhyK9FhSZCh//+44kqNCeX97MY0tJ07PFKIzUryF6EJxTROvrnXvL3LN5Cxy0r23q0tEqIULclKpa3Hw8a5Sr51XBD4p3kKcRGF1I6+ty8NshqtOyeqTKX5pMTamDopn85Fq9pcF1o5Tou9I8RaiE0U1TSzecIQQi5mrT8kiMbLrxap6asaQBBIiQnhvexHNds/uYhXBTWabCNGBxhYHdy3ZRovDxZWTMomPOLFwL/vN4157PavFzAU5qSxak8fqgxWcPjTRa+cWgUl63kIcx+Vy8bsPd7GzqJaLxqaS3MlQSWNsAo2xCV573ay4cIYmRbAhrwqH3FIvuiA9byGO88raPD7YWcItM7KJDe98EbARH7jXed913mVHH+vtTlCnDIzj3+uPsKOohjHpMb06lwhs0vMWop1thTUs/GI/Z49I4tpTT77MgPrgv6gP/uvV1x+cEEFiZAhrD1V2/WQR1KR4C9GqocXB/e/uJCkqjF+fMwJTL+dx94TJZGLSgDgKqpvIr2rs99cX/kOKtxCtHv98H4crGnhgjiLaZtyI4tj0GMKsZul9i5OS4i0EsGJfGW9uKuCqU7I4ZWDX66b3pVCrmdyMGHYW1VDT2P21zkVwkOItgl51Ywu//WAXw5Mjufm0bKPjADBpQCxOF2zKrzI6ivBRHn02VEo9DJyNu9iv0FrPb3dsNvA6sLPdt9yotd7jxZxC9Jm/fb6fqoYW/nbZ2G4tMvXe7zveBNob4iNCGRBnY2dxLTNkzrfoQJfFWyl1ATADmNb60Gql1Cyt9eftnva+1vraPsgnRJ9ac6iCJVsLuWbyAFRq95ZltdvC+yiV24iUKD7eVUp5fTMJHdwkJIKbJ92MD4ALtNZOrbUTKAOS+jaWEH2vscXB75ftJivOxo+mDez2949e8iqjl7zaB8ncVIr7j8mu4ro+ew3hv7rseWut7UAtgFJqCqBwF/T2JiillgApwDLggdZCL4TPem7VIfIqG3nqO2OxhVi6/objDP38fQC2X3yVt6MBEBseQlp0GLq4lqnZ8X3yGsJ/eTwfSil1OvAy8G2tdfuV43cDDwP/AWzAO8B1wAvtvz8+PgKrtfu/IL4sOdl7S4P6mkBv287Cal5dl8d3JmUxd1Lnve7oqIpOj1lad82JjrJ5PWObsQPiWLa9CKfFcszdnh29P4H+ngWqnrbN0wuWs4C/4x4+aX9hEq11PrC49ct6pdTbwITjz1FREVhLXQb7pqj+Kjk5muLiau5+YxNRoRZumjLgpG2tqe38RhmHw9nlc3orO9b9h2HDgTImDfhmCuPxmQP9PQvmtnVW3Lsc81ZKJQDPAOcfX7hbj1/TOhsFpZQZOBPY0HVsIYzxzvYiNuZXc9vMwcSdZO0SX5AUFUpCRAi7imWbNHEsT3reNwBxwMtKqbbHFgE/AM4C3gJeUkp91XpsNe7hFSF8TlV9C3/7fD9j02O4cEya0XE8olKi+OpgBfXNDiJCA2voUfScJxcsHwUe7eBQ25h2LfAdb4YSoi+8tbmAT/aUUdnQwqXj0nl7S2Gvzrf0sUVeSnZyKiWKVQcq2FNaR26GrDQo3OQOSxE0Cqsb+Xp/OZMGxJEa7f3tzPpKWkwY0WFW9pTIlEHxDSneIii4XC4+3FlCRKiF04d6ZwOF3MUvkLv4ha6f2Esmk4nsxHAOVtTjdMkmDcJNNmMQfqm7mx5sLagmv6qRyyZk9mhOd0cGffUZAJu/e4NXzncy2QkRbDlSQ1FNE+kxfTc1UfgP6XmLgNdkd/LprlLSY8KYOMg/b3bJTogA4GB5YE25FT0nxVsEvJX7y6ltdnDOyBTMBmyw4A1RYVaSIkM5UN5gdBThI6R4i4BWXt/M1wcrGJsRTWasfw83ZCdEcLiiAbtTVp4QUrxFgPtsdykWs4nZw7y/lpo9LAx7WP/NWslOCMfudJFfKdujCblgKQLYoYoGdHEdM4cmEhXm/R/19x553uvnPJkB8eGYQIZOBCA9bxGgXC4XH+sSosOsnDrI2G3NvMUWYiE91sYBuWgpkOItAtTWghoKa5qYPTyREEvf/JhPfGUhE19Z2Cfn7kx2QjgF1Y3UNsnelsFOircIOC0OJ5/vKSMtJoyctL5bSjRz/Vdkrv+q6yd6UXZCBC4XrM+TvS2DnRRvEXDWHa6kpsnOWSOSMfnp1MDOZMbasJpNfH2w83XGRXCQ4i0CSmOLg1X7KxiSGMHA+L7dY9IIVouZrDib9LyFFG8RWFYfrKDR7mTWsMDdcT0rLpw9JXUy7h3kpHiLgFHXZGfNoUpGpUaR1g/rfzTGxNEY0/8zWQbEheMCNh2p7vfXFr5D5nmLgLFyfwV2p4vTh/ZPr3vZA0/0y+scLyPOhsVsYmNeFacN9s4KicL/SM9bBISqhhY25FWRmx5DYmSo0XH6VKjFzMiUKDbly7h3MJPiLQLCVwcrcOHitCH91xM99fm/cOrzf+m312tvXGYM2wpraLbLOifBSoq38Hu1TXY25VczJj2G2H7cUDh1+0ZSt2/st9drb0JmLM0OF9sLA3NXddE1Kd7C7605VInT6WJatn+u1d0T4zLde1lulKGToCXFW/i1hhYH6w9XMjI1ioQAH+tuLz4ilOyEcDbmy4yTYCXFW/i1dYcqaXa4mB6Esy7GZ8ay6UiV7GsZpKR4C7/VbHey5nAlw5IiSTFgN/i65FTqklP7/XXbTMiKpbbJwd5S2VU+GMk8b+G3Nh2porHFyfTBxox1f/KrPxvyum3axr035FUzfXS6oVlE//OoeCulHgbOxt1TX6G1nn/c8fuACwAT8I7W+iFvBxWiPZfLxdpDVWTG2siMC7w1TDyREWMjJSpULloGqS6HTZRSFwAzgGnAFGCGUmpWu+NTgMuAmcDpwIVKqel9E1cItz2ldVQ2tHDKQOM2Wpj+1MNMf+phw17fZDIxLjNWbtYJUp6MeX8AXKC1dmqtnUAZ0H5DwPOBJVrrZq11M7AEmOv9qEJ8Y+2hSqLDrKiUKMMyJO7ZSeKenYa9PsC4jBiKa5vJr5St0YJNl8MmWms7UAtHe9kKd0FvkwGsb/d1IXBCzzs+PgKr1dKrsL4mObnvFvo3mi+3bVdRDQfKGzh3dCpxMd0fMomO8s6iVZbWHXq8db7uaHt/Zo9J58+f7mXtgXIuHp/Z7zn6iy//PPZWT9vm8QVLpdTpwMvAt7XWtSd5qgk4Ye5SRUVg7buXnBxNSUlg3t3m6217+uNdWM0mRiVHUlPbvZ3Uo6Ns3f6ezjgc7lvTvXW+7mh7fxKtJsJDzKw7WMH01guYgcbXfx57w5O2dVbcPZoq2DrG/Szu4ZP1xx0+jLv33SYDyPPkvEJ0V1VDC+9uLyYnLZqI0MD6JNcTVrOJnPQY1h6QnXWCjScXLBOAZ4DztdYdDfC9A1yilLIppWy4L14u9W5MIdyWbiuiye409EJlm6qsbKqyso2OwbiMGHYWVlPXLJszBBNPhk1uAOKAl5VSbY8tAn4AnKW1Xq+UWgQsxz1cskhrvbYvworg5nK5eHtzAbkZMYbclHO85Xf81ugIgHu+t9MFWwtqmDIoeNZ3CXaeXLB8FHi0g0MvePAcIbxmY341BysauP/UAbQ45ZbwNmPTYzCZYHN+tRTvICK3xwu/8faWAiJDLZytko2OAsDMx+5j5mP3GR2DqDArKjWaTUdkvncwkeIt/EJ1Ywsf7yplzqgUwkN840JlbN4BYvMOGB0DgFOy49laUINDPpEEDSnewi+8v6OEJruTS8amGR3FJ50yKIG6Zgd7ZJGqoCHFW/g8l8vF21sKGJkSxcjUwL1ZozcmtY51b5L1vYOGFG/h87YX1bK7pI6Lpdfdqaz4cJKjQtks495BQ5aEFT5v6dZCwqxm5oxKMTrKMcqGjTQ6wlEmk4lxGTGys04QkeItfFqz3clHuoTZwxKJCvOtH9eVt9xjdIRjjM+M5aNdpRRWN5IW0//rrYj+JcMmwqd9ub+cqkY75482bscafzE+KxaADbJEbFCQ4i182rvbi0iICPHJm0/OfOTnnPnIz42OcdSwpEgiQy1szJOhk2DgW59DhWinsqGFFfvK+e6EDKxmk9FxThBZUmR0hGNYzCbGZcawIU963sFAet7CZ32kS7A7XcyVIROPjc+MZX95PZX1LUZHEX1MirfwWe9uL2JoUgQjkiONjuI3JmS6x71lX8vAJ8Vb+KRDFQ1sKahh7qhUTCbfGzLxVaPTogm1mOSiZRCQMW/hk97bXoQJfG5ud3tFo8cbHeEEoVYzOWnRMt87CEjxFj7H5XLxoS5h0sA4n1i3uzNf33in0RE6ND4rln9+fZj6ZofsNhTAZNhE+JydxbUcqmjgPB9Z+tXfTMiKxeGCLQXS+w5kUryFz/lgRwlWs4kzhicZHeWkznngNs554DajY5xgbHoMZhNslCmDAU2GTYRPcbpcLNPFTM2OJzY8xOg4J2WrrjQ6QoeiwqyMSI6SGScBTnrewqdszK+iuLaZ80b67oVKfzAhK5YtBTU0251GRxF9RIq38Ckf7iwhzGpm5tBEo6P4tVMGxtFkd8q4dwCT4i18ht3h5ONdpcwcmiizJHppYlYsFhN8fcg3h3ZE70nxFj7j60OVVDa0cN5I/5hlkj9xKvkTpxodo0NRYVZGp0Wz5qAU70AlFyyFz/hQlxAVZmFadoLRUTyy/upbjY5wUqcMjOOfXx+mtsnuc2uhi96Td1T4hMUb8/lIlzAiJZL/2+5bq/X5q8kD43hp9WE25FVxulxDCDgeFW+lVBrwKhCmtZ5x3LFsYGPrf23u1Vqv8FZIEfj2l9XTZHcyyo82GD7/VzcC8N4jzxucpGO5GbGEWc2sPVwpxTsAedrz/hfwPnBhJ8c3aq1neyWRCEo7imqxWc1kJ0QYHcVj1qYmoyOcVJjVTG5GDGvkomVA8rR4XwxMpPPiLUSPNdmd7C6uY1RqFBYf3HTBF721ueCYr6OjKqipbTzheRGhFtYcqqS8vpmEiND+iif6gUfFW2tdrZQ62VMGKqXeBNKBtcDdWuv69k+Ij4/Aag2s6V/Jyf7zEb+7+rNtH24rpNnhZGJ2AtFRfb9xrrdew2Ixe/V8vdVRjtGZcXy+p4xdlU1cOMh/h07kd+1E3rhgWQY8CLwOOIB/AL8C7mv/pIqK+hO/048lJ0dTUlJjdIw+0d9te3PNIcJDzCSHWzvsPXpTdJTNa6/hcLjvXuzrzJ7orF0xVhNhVjMfby1gaoZ/FsBg/13rrLj3unhrrWtwF2wAlFKLgR/19rwiODS2OPhibzkqxf+GTA5OnW10hC6ZzSYGxofLuHcA6nXxVkqdDXwfuEFr7QLOBjb09rwiOKw6UEF9i4ORfjTLpM3m795gdASPZCdEsEyXcLC8nkF+dEFYnFyXxVspNRD4JxAHDFZKfQa8A0wC7gQ+Ay4H1iilmoD9uIdNhOjSMl1CXHgIg+LDjY4SsIYlR7JMl/Dl/nIp3gGky+KttT4EzO7iaT/xShoRVBpbHKzYV8b5o1Ix+9mQCcCFd/wAgKWPLTI4ycnFhYcwJDGCL/aV8/1JWUbHEV4ia5sIw6w8UEFDi5OzRvj2pguBYMaQRDbkVVHbZDc6ivASKd7CMB+1DplMHBBndJSAd/qQBBxOF18dqDA6ivASKd7CEG1DJmcMT8Tqh0Mm/mZMRgyxNisr9pUZHUV4iRRvYYhvhkz8Y/lXf2c1m5g2OIEv91fgcLqMjiO8QIq3MMTHrUMmk/x4yGTvrDnsnTXH6BgeO31IApUNLWwrDMwbXoKNLAkr+l1ji4Mv9pUxZ1SKXw+ZbL/4KqMjdMvU7HgsJlixr4zcjBij44hekp636HeBMmRibWzA2thgdAyPxdhCGJcZy4p95UZHEV4gxVv0u0AYMgE4/9c3cf6vbzI6RrecPjSR3SV15FX6zx8d0TEp3qJftQ2ZzB4ms0yM0DanfpkuMTiJ6C0p3qJfrWodMjnbz4dM/FV6jI3cjBg+3CnF299J8Rb96uNdJcTarEwa6N9DJv7sXJXMntJDisT0AAAXG0lEQVQ69pbWGR1F9IIUb9Fv2pZ/PWN4kgyZGOgslYzZJEMn/k6Kt+g3bcu/BsqQiT7vUvR5lxodo9uSIkOZNCCOZboEl0tu2PFXMs9beN3x+yu2WbKlgPAQM4crG8jfbPzuM72167zLjI7QY+eqZB5etpudxbWM8sO11IX0vEU/aXE42VNSx4iUKL9c/rUjtqpybFX+OWe6behKLlz6Lyneol/sL6un2eFiZGqU0VG85pwHb+ecB283OkaPxIaHMDU7nmW6BKcMnfglKd6iX+woqiU8xMygeNnJxVecNzKFopom1sr+ln5Jirfoc+4hk1pG+OEmw4HsjOFJxNqs/HdzodFRRA9I8RZ9bl/rkMmoABoyCQRhVjMX5KTy2Z5SyuubjY4jukmKt+hzOwprCA+xyJCJD7pkbDp2p4v/21pkdBTRTTJVUPSptlkmY9KjA2aWSZvtF15pdIReG5wYwYSsWP67pYCrJ2dhNgXWexTIpOct+tTe0jpanC5GpQXeXOK9Z8xl7xlzjY7Ra5flppNX2cgauXDpV6R4iz61o7CWyFALA+LDjY7idZHFBUQWd3xDkj858+iFS/9vSzDxaNhEKZUGvAqEaa1ndHD8RuAmwA5sBOZprZ3eDCr8T7PdyZ7SOnIzYwLy4/iZf/gFAEsfW2Rwkt4JtZr5Vk4ar2/Ip7SumaTIUKMjCQ94Oub9L+B94MLjDyilsoD7gHFAFfA2cAXwmpcyCj+1p7QOu9Mlt1/7gM6WLGgTZbPgcLr47QeaWcPca35flpveH9FED3k6bHIxsLqTY2cDn2qtK7XWLuANwP8HAkWv7SiqISrUwoA4m9FRRBcSIkJRKZGsP1xFs10+NPsDj4q31rr6JIczgPaz/AtbHxNBrMnuYG9pPSNTozEF4JBJIJoyKJ5Gu5NNR6qMjiI80BdTBU3ACYslxMdHYLVa+uDljJOcHLjDAb1pW3RUBbsPVuBwujhlSCLRUb7V8/ZWHovF7NXz9VZvc4yMspG9r5y1h6uYNTLNp36+fSmLt/W0bd4o3oeBc9p9nQHkHf+kiop6L7yU70hOjqakpMboGH2it22rqW1k3cFy4sKtxIWYqKn1neVfo6NsXsuz4bIfAvhE+7zVrlMGxPKfjQWs2VvKnGEJXkjWe8H+u9ZZcfdG8V4G/E4plQhUAFcCz3nhvMJP1TfbOVBez9RB8QE9ZHJw2plGR/C6YUmRJEaGsPpgBS6XK6DfP3/XZfFWSg0E/gnEAYOVUp8B7wCTgDu11vlKqXtwz0axAyuBt/ossfB5O4pqcblgdADemNNe7OF9AFQNGGJwEu8xmUxMGRTPu9uL+epgBdOyfaP3LU7UZfHWWh8CZnfxnFeAV7yUSfi5HYU1JEWGkhIdZnSUPjVzwW8A/5/nfbyc9GhW7CvnuZUHA/7Tkz+TOyyFVxVWN3K4sjHge92BzGo2M31wAlsKalh1oMLoOKITUryFV7XtSD46TZZ/9We5GTGkx4Tx7MqDskmxj5LiLbzqw50lpMeEER8ht1j7M4vZxPVTBrKtsIYv9/vnPp2BToq38Jr9ZfXsLK6VIZMA8a2cVDJibdL79lFSvIXXvLu9CIsJcoKkeK+/6mbWX3Wz0TH6jNVi5oYpA9lRVMvyvWVGxxHHkeItvMLpcvHejmKmZicQGRYce3zkT5pO/qTpRsfoU3NzUhkYH87CFQdwOKX37UukeAuvWH+4iqKaJuaOTjE6Sr9J3LODxD07jI7Rp6xmE7fOyGZ/WT3vbJet0nyJFG/hFe9uLyIy1MLMoYlGR+k305/6PdOf+r3RMfrcGcOTyEmL5pkvD9DY4jA6jmglxVv0WmOLg493lXLWiCRsIYG1+Jhw33V528zBFNc288bGI0bHEa2keIte+3xPGfUtDuaOTjU6iugjkwbEcdrgBF5afZjqxhaj4wikeAsveHdHEWnRYUzIijU6iuhDt56eTW2TnRe/Omx0FIEUb9FLpbVNrD5QwZxRKQG5T6X4xvDkKC4ck8rijfnkVTYYHSfoBcecLtFnlm4rwuGCC8ekGR2l3319w3yjI/Spjva9HBgfAcCvlu7g0nHH7nEpe172LyneosecLhdLthQyaUAsA+PDjY7T74pyJhodod9F26xMzY7ni73lHK5oYEAQvu++QoZNRI+tO1xJflUjF48Nvl43QOq29aRuW290jH43ZVA80WFWPtpVIrfNG0iKt+ixJVsKibFZOXN4stFRDHHqCws49YUFRsfodyEWM7OHJ1JY3cTWgsDcnswfSPEWPVLZ0MInu0s5f1QKYVb5MQo2OWnRpMeE8enuUprscuOOEeS3TvTIezuKaXG4gnbIJNiZTCbOHZlCXbODL/fJkrFGkOItus3lcrFkSwE5adEMT5ZNF4JVRqyN3IwY1hyqpKyu2eg4QUeKt+i2TfnV7C2tl163YPbwREIsZj7cKRcv+5tMFRTd9vqGfGJsVuaMCp4VBDuy8pZfGx3BcJGhVk4fmshHuoRP95Rx5vAkoyMFDSne4qSOv1GjqvVC5ZRB8by3o9igVL6hbNgooyP4hElZsWzKr+Ivn+zh1IFxRAXJeu5Gk2ET0S3r86oAmCjrmJC5biWZ61YaHcNwZrOJ80elUFLbzN+/PGB0nKAhxVt4rNnhZGNeFSo5itjwEKPjGG7iq08z8dWnjY7hEzLjwvnO+AwWbzjC1oJqo+MEBY8+3yil7gMuAEzAO1rrh9odywY2tv7X5l6t9Qov5hQ+YOuRahrtTk4ZGGd0FOGDbp6RzWd7Snn4w90sunoCVov0DftSl8VbKTUFuAyY0vrQl0qpj7TW7T8vbtRaz+6DfMJHuFwu1h6uIi06jKw4m9FxhA+KCrPyi7OG8fMl21m0No/rpgw0OlJA8+RP4/nAEq11s9a6GVgCzO3bWMLX7C2tp6yumVMGxmGSpV9FJ2YNS+LsEUk8u/IguqjW6DgBzZPinQEUtvu6sPWx9gYqpd5USq1USv1NKRXhtYTCcC6XixX7yoi1WRmdFm10HOHjfnn2cOLCQ7jvvZ2y52Uf6smcHhPQfjZ+GfAg8DrgAP4B/Aq4r/03xcdHYLUG1v6GycmBW8ja2hYdVYEurKaguolLJ2QSF+P/S4BGR3ln2GfdPX/w6vl6y+gcbT8zycBj3xvPNS9+zQtr83ngohyvnTsQ9bRtnhTvwxzb084A8tq+0FrX4C7YACilFgM/Ov4kFRX1PQroq5KToykpCcwV1dq3rbqmgQ+3FRJrszI8IZya2kaD0/VOdJTNa22oScx0/8MH/p94s1091f73YVS8je9NyODllQeYlB7F1OyEHp83WH7XTvacjngybPIOcIlSyqaUsuG+eLm07aBS6myl1ItKqbaB0LOBDZ4EF75vX1k9BdVNTBucgMUsY93tDVr1CYNWfWJ0DJ817/TBDE6M4P53NYXVxv+BCzRdFm+t9XpgEbAc+BxYpLVeq5R6XSmVCXwGNANrlFJfAvHAH/susugv7rHucmJsVnIzYoyO43Ny33iJ3DdeMjqGz7KFWPjThaNpdji5a8l2Gf/2Mo/GvLXWjwKPHvfYFe2+/Ik3QwnfsGJfOUeqGpkzKkV63aJLHe15CXD+6BT+s7GAnyzezIVjUo+ZrST7XvaczKIXHWq2O1nw2V4SIkKk1y16ZXhyFDOHJrKtsIbVByuNjhMwpHiLDr26Lo/DlY2cMzJZet2i16YPjmdkahSf7i5lY+v6OKJ3ZPkvcYKCqgZe/OoQs4clMiQx0ug4IgCYTCYuHJNKi8PJezuKMZtN8omul6R4ixP8/t2duICfzR4iH3NP4pO7/2R0BL9iNZu5LDedNzYe4d1tRVhMMubdGzJsIo6x+mAFSzcd4ZrJWWTG+v8NOX2pLiWduhQpPt1htZi5fHwGA+LD+d/WIl5afUh24OkhKd7iqMr6Fh54TzMkOZJrJg8wOo7PG/rpuwz99F2jY/idEIuZ707IYHRaFE+tOMB978pt9D0hxVsA7jndD32gqWps4YkrJ2ALCaylDPrC6KX/YvTSfxkdwy+FWMxcNCaNW2Zk8+HOEm58fRN7SuqMjuVXpHgLAN7YeIQv9pXz05lDyMmQXXJE3zOZTFw3ZSB/viSH4pomfvDKep5deYAWh9PoaH5BirdgZ1ENj3++jxlDEvjehOMXjBSib80cmsjia0/hHJXMc6sOcdWi9Xy+p0zGwrsgxTvI5VU2cPtbW4kLD+H+80bIWt3CEHERITw0dyQLLs3B4XTx8yXbuOFfG1lzqEKKeCdkqmAQK6tr5rY3t+Bwunj6u7nER4QaHUkEmY5uqb9iYiZbjlSzYl85t7yxhayP9nDKgFhUShTmHnQuAnU6ohTvIFXbZOf2t7ZSUtvMU9/JlZtxemDZbx43OkJAsphNjM+KZUx6NJuPVLP2cBVvby4kLjyESQNiyc2IkQvqSPEOSqW1Tcz/7zb2lNbxl0ty5E63HmqM7fka1aJrVouZiQPiOH1kKuv3l/H1wQo+3lXKF3vLGJsRwykD40gI4k+LUryDzDMrD7B4wxEamh1cmptGUU3TCR9do6MqDF/Y3x+M+OAtAHadd5nBSQKb2WRCpUShUqIoqG5k7aFKNuRVse5wFSOSIzl1UDxZcbagu14jxTuIrNxfzqI1eVjNJq6anEV6jG9s3+Wv1Af/BaR496f0GBsXjknjjOFJrDtcyfq8KnaV1JEVZ2P64ASGJEYETRGX4h0EGlscPLF8P4s3HiE5KpTvjM8gNjzE6FhC9FhUmJVZw5KYNjiBzfnVrD5YweINR0iLDmPG0ASGJUUGfBGX4h3gthZU8+D7mgPlDVwxMZOsOBshFpkhKgJDqMXMKQPjmJAVy9aCalbur+A/GwvIjLUxa1gigxIijI7YZ6R4B6iS2iYWfrGfd7YXkxwVypPfHsuU7PhOdzsRwp9ZzCbGZcYyJj2GzUeq+XJfOa+ty2dwYgQ5adGolCijI3qdFO8AU9XQwr835PPK2jzsThfXTB7AdVMGEBUmb7UIfBaziQlZsYxNj2Z9XhVf7ivnB4vWM2dUCjfPyA6o6zym/rp7qaSkJqBuk0pOjqakpMbQDO170bVNdtYcqmT94UqaHS5USiRnDE/q0Y030VG2gJ1t4s22WRsbALDbjF86V96zjjW2OCira+H19Xm4gO+Oz+S6KQN85pqPJ3UkOTm6w8F76Y75MZfLxaGKBjbkVaGLa3G6YFRqFNMHJ5ASHWZ0vIDnC0VbnJwtxMJtM7P4zvh0nll5kNfW5bFkawHXTB7A9yZkEhHqvzf7SPH2My6Xi13FdSzbVcKSLYVUNrRgs5qZNMB90SYxMnhvWuhvo5e8CsD2i68yOInoSlqMjd/MUVw1KYuFK/bz1IoDvLYun2smZ3H5+AzC/fCOTSnefqC8vpm1hypZc6iSrw9WcKS6CYsJBsRHMGNIAiNTo2QGiQGGfv4+IMXbnwxLjmTBpWPYcqSaZ1ce5G/L9/OPrw/z7XHpfGd8BklR/vOJVYq3D2lscXC4soFDFQ0cKK9nZ1EtO4tqKaxpAiAqzMKkrDiumzKQ2cOS+GRPqcGJhfBPYzNieOLysWzKr+KVtXm8tPow/1yTx1kjkpg7OpVTB8VjNfv2PHGPirdS6j7gAsAEvKO1fui44zcCNwF2YCMwT2sdMCuqdzS9rv0t5C6XCxfgcoHT5cLpcuFwgt3ppMXhosXhpNnhosnuoLHFSaPdQX2z+7+6ZgfVjXaqG+00HLcV1MD4cHIzYvhuahQTs2JRqdE+/wMlhD8ZlxnLuMxYDlc08Pr6fN7bUcwHO0tIiAjhrBHJTM2OZ9KAWCJDfa+f22UipdQU4DJgSutDXyqlPtJar2w9ngXcB4wDqoC3gSuA1/okcQ+5XC4a7U6qGlqoarBT2dhCVUMLla1fVzW2HC2idc12d3FtcdBkd1LbZMfudOF0tRZqF/R26ozJBBEhFiJDLUTbrKTHhDE1O54BceEMSohgYHy4X47DCeGPBsSHc9dZw7h91hBW7C/nve1F/G9rIW9sPILFbGJ0qnttlREpUQxNiiQ9JozEyNAeLVHrLZ78OTkfWKK1bgZQSi0B5gIrW4+fDXyqta5sPf5G63GvFO/C6kY+3FmCo7VoOlwunM7W3q0L7A7X0R5uk91dbBvtThpavunZ1jTaqWktwJ2JCrMQYwshJsxKVJiFtBgb4SFmbCEWDlc2YDWZMJtNmHBv3xQWaqW5xU7bW2cygQkTJhNYzSbMJhMWs4kQi4lQi5kQixmb1UxYiBmb1UJ4iPmE23cDdd1hIfxFqNXMmcOTOHN4Es12J5uOVLH6YCWbj1Tz3o5i/rPpm0/hVrOJlKhQd92wWYm2WbGFWNy/51YzVrMZqxniIkK5LDedMKt3r0t5UrwzgPXtvi4Eph93vPC44yfspdXZXMWuJCdHM3Zock++NeD9+KxooyMEt02rAfixwTFE38lMj2XupIF9+hrJyT37Pe7JnwITJx816Oq4EEKIXvKkeB/m2J50BpDXjeNCCCG8zJPi/Q5wiVLKppSy4b54ubTd8WXALKVUolLKDFwJ/M/7UYUQQrTpcsxba71eKbUIWI57OGSR1nqtUup14E6tdb5S6h7gfdxTBVcCb/VlaCO0zrpZgLuNdcA1WuuS455jA14ARuL+w/hTrfUX/Z21uzxpW7vnDgC2AhdrrT/rt5A94OF7NhZ4svXLMOAWrfV6fFQgT9v1oG3zgB8CDmAvcF3bRApf11Xb2j3vdmC+1jq7q3N6NOattX5Ua32q1nqK1vrPrY9dobXOb/33K1rryVrraVrrO7XWgTjm/TLwM631TNyfNh7u4Dl3AzVa60nADcD3+i9er7xM121DKWUCngF29l+0XnmZrtv1IvCQ1noW8HvgL/0Xr3vaTdudCZwOXKiUmt7ueNu03XOB04BM3NN2fZ4HbRsD/BSYobWeCthwf8r3eV21rd3zRuAu8B6Re6o9oJTKBsK11l+3PrQY93TI430b+Du4P7Foref1T8Ke60bbAH4CrAF29EO0XulGu84GPmn9dzGQ1PfpeuzotN3WHmfbtN02R6fttnag3qDz99LXdNW27cAkrXVT69cl+PZ71V5XbaN1yPnvwO2enlSKt2c6mg7Z0aTsYcBUpdTHSqlPlVLT+iVd73jUNqXUEOAq4Hf9lKu3PGqX1rpKa+1q/VTxS9w9cV/V1bRcj6bt+qiTZtdaO7XWNQBKqcG4e6iL+zVhz3nyvtwFvK+19rhj5Hv3fBpMKXUdJ/71Kz/u65NNh2zUWp+llJoJLFZKDfSVYaSetq21V/As7vHTFqVU34Xsgd6+Z0qpEOAfQCXwV68H7DuBPG23w+xKqVG4e64/0lof7vdU3nFM25RSObh752d15yRSvI+jtX4JeKn9Y60X6b5s91AGkN/Btx+h9SO41nq5UioC90e7Di/+9bdetE0Bg4G/txbuocCpSqmfaK2X911iz/TmPVNKWXBfYN8G/MpX/tB2wpNpu+ec5Lgv63LKsVJqNO7Cfa3Wuv176+u6atu3gQTcS48ApCullmmt27+XJ5BhEw+0/oWvUEqd1vrQ1XQ8HfJt4GI42kNoAnx66T9P2qa13qG1Hqq1ntp6segd3LMyDC/cnenGe3af++n6bh8v3BDY03ZP2jalVCjwOnCFnxVu6KJtWuuHtNa57X6/Croq3CA97+64FnhSKeXC/ZH8hwBKqWsBi9b6BeAB4B9KqStw/2G8yg8KAnjWNn90LV236y5gi1Lqs3bfd5bW+tglHn1AIE/b7aptuJfkGAj8pd2w3TKtdYczo3yJJ+9bT87bb3tYCiGE8B4ZNhFCCD8kxVsIIfyQFG8hhPBDUryFEMIPSfEWQgg/JMVbCCH8kBRvIYTwQ1K8hRDCD/0/d5nkz+Nl2VkAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.distplot(post_pred['obs'].mean(axis=1), label='Posterior predictive means', ax=ax)\n",
    "ax.axvline(data.mean(), ls='--', color='r', label='True mean')\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Predicting on hold-out data\n",
    "\n",
    "In many cases you want to predict on unseen / hold-out data. This is especially relevant in Probabilistic Machine Learning and Bayesian Deep Learning. While we plan to improve the API in this regard, this can currently be achieved with a `theano.shared` variable. These are theano tensors whose values can be changed later. Otherwise they can be passed into PyMC3 just like any other numpy array or tensor.\n",
    "\n",
    "This distinction is significant since internally all models in PyMC3 are giant symbolic expressions. When you pass data directly into a model, you are giving Theano permission to treat this data as a constant and optimize it away as it sees fit. If you need to change this data later you might not have a way to point at it in the symbolic expression. Using `theano.shared` offers a way to point to a place in that symbolic expression, and change what is there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (4 chains in 4 jobs)\n",
      "NUTS: [x]\n",
      "Sampling 4 chains: 100%|██████████| 4000/4000 [00:00<00:00, 6878.69draws/s]\n",
      "The acceptance probability does not match the target. It is 0.8860942205889539, but should be close to 0.8. Try to increase the number of tuning steps.\n"
     ]
    }
   ],
   "source": [
    "import theano\n",
    "\n",
    "x = np.random.randn(100)\n",
    "y = x > 0\n",
    "\n",
    "x_shared = theano.shared(x)\n",
    "y_shared = theano.shared(y)\n",
    "\n",
    "with pm.Model() as model:\n",
    "    coeff = pm.Normal('x', mu=0, sigma=1)\n",
    "    logistic = pm.math.sigmoid(coeff * x_shared)\n",
    "    pm.Bernoulli('obs', p=logistic, observed=y_shared)\n",
    "    trace = pm.sample()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now assume we want to predict on unseen data. For this we have to change the values of `x_shared` and `y_shared`. Theoretically we don't need to set `y_shared` as we want to predict it but it has to match the shape of `x_shared`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [00:03<00:00, 157.63it/s]\n"
     ]
    }
   ],
   "source": [
    "x_shared.set_value([-1, 0, 1.])\n",
    "y_shared.set_value([0, 0, 0]) # dummy values\n",
    "\n",
    "with model:\n",
    "    post_pred = pm.sample_posterior_predictive(trace, samples=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.014, 0.514, 0.988])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "post_pred['obs'].mean(axis=0)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
